【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili
教程源地址:https://www.udemy.com/course/2d-rpg-alexdev/
udemy的Alex银河战士恶魔城,记录我自己的学习,代码会逐渐每一p更新,仅供参考学习
Skill
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Skill : MonoBehaviour
{
[SerializeField] protected float cooldown;
protected float cooldownTimer;
protected Player player;
protected virtual void Start()
{
player = PlayerManager.instance.player;
}
protected virtual void Update()
{
cooldownTimer -= Time.deltaTime;
}
public virtual bool CanUseSkill()
{
if (cooldownTimer < 0)
{
UseSkill();
cooldownTimer = cooldown;
return true;
}
else
{
Debug.Log("Skill is on cooldown");
return false;
}
}
public virtual void UseSkill()
{
//放技能
}
protected virtual Transform FindClosesetEnemy(Transform _checkTransform)//寻找附近的敌人,返回最近的敌人
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(_checkTransform.position, 25);//碰撞体检测周围的敌人
float closestDistance = Mathf.Infinity;
Transform closestEnemy = null;
foreach (var hit in colliders)
{
if (hit.GetComponent<Enemy>() != null)
{
float distanceToEnemy = Vector2.Distance(_checkTransform.position, hit.transform.position);
if (distanceToEnemy < closestDistance)
{
closestDistance = distanceToEnemy;
closestEnemy = hit.transform;
}
}
}
return closestEnemy;
}
}
SkillManager
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class SkillManager : MonoBehaviour
{
public static SkillManager instance;
public Dash_Skill dash{ get; private set; }
public Clone_Skill clone { get; private set; }
public Sword_Skill sword { get; private set; }
public Blackhole_Skill blackhole { get; private set; }
public Crystal_Skill crystal { get; private set; }
private void Awake()
{
if (instance != null)
Destroy(instance.gameObject);
else
instance = this;
}
private void Start()
{
dash = GetComponent<Dash_Skill>();
clone = GetComponent<Clone_Skill>();
sword = GetComponent<Sword_Skill>();
blackhole = GetComponent<Blackhole_Skill>();
crystal = GetComponent<Crystal_Skill>();//获取组件才能发挥功能啊
}
}
Dash_Skill冲刺技能
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Dash_Skill : Skill
{
public override void UseSkill()
{
base.UseSkill();
Debug.Log("clone");
}
}
Clone克隆技能
Clone_Skill
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Clone_Skill : Skill
{
[Header("Clone Info")]
[SerializeField] private GameObject clonePrefab;//克隆原型
[SerializeField] private float cloneDuration;//克隆持续时间
[SerializeField] private bool canAttack;// 判断是否可以攻击
[SerializeField] private bool createCloneOnDashStart;//在冲刺开始时创建克隆
[SerializeField] private bool createCloneOnDashOver;//在冲刺结束时创建克隆
[SerializeField] private bool canCreateCloneOnCounterAttack;
[Header("Clone can Duplicate")]
[SerializeField] private bool canDuplicateClone;//可以重复clone
[SerializeField] private float chanceToDuplicate;//重复clone的几率
[Header("Crystal instead of clone")]
public bool crystalInsteadOfClone;//是否使用水晶代替克隆
public void CreateClone(Transform _clonePosition,Vector3 _offset)//传入克隆位置
{
if(crystalInsteadOfClone)//克隆转换成水晶
{
SkillManager.instance.crystal.CreateCrystal();
SkillManager.instance.crystal.CurrentCrystalChooseRandomTarget();
return;
}
GameObject newClone = Instantiate(clonePrefab);//创建新的克隆//克隆 original 对象并返回克隆对象。
newClone.GetComponent<Clone_Skill_Controller>().
SetupClone(_clonePosition, cloneDuration, canAttack,_offset,FindClosesetEnemy(newClone.transform),canDuplicateClone, chanceToDuplicate,player);
}
public void CreateCloneOnDashStart()
{
if(createCloneOnDashStart)
CreateClone(player.transform, Vector3.zero);
}
public void CreateCloneOnDashOver()
{
if (createCloneOnDashOver)
CreateClone(player.transform, Vector3.zero);
}
public void CreateCloneOnCounterAttack(Transform _enemyTransform)
{
if(canCreateCloneOnCounterAttack)
StartCoroutine(CreateCloneWithDelay(_enemyTransform, new Vector3(2 * player.facingDir, 0)));
}
private IEnumerator CreateCloneWithDelay(Transform _transform,Vector3 _offset)
{
yield return new WaitForSeconds(.4f);
CreateClone(_transform, _offset);
}
}
Clone_Skill_Controller
using UnityEngine;
//P65克隆控制
public class Clone_Skill_Controller : MonoBehaviour
{
private Player player;
private SpriteRenderer sr;
private Animator anim;
[SerializeField] private float cloneLosingSpeed;//加速消失时间
private float cloneTimer;
[SerializeField] private Transform attackCheck;
[SerializeField] private float attackCheckRadius = .8f;
private Transform closestEnemy;
private int facingDir=1;
private bool canDuplicateClone;
private float chanceToDuplicate;
private void Awake()
{
sr = GetComponent<SpriteRenderer>();
anim = GetComponent<Animator>();
}
private void Update()
{
cloneTimer -= Time.deltaTime;
if (cloneTimer < 0)
{
sr.color = new Color(1, 1, 1, sr.color.a - (Time.deltaTime * cloneLosingSpeed));//逐渐消失
if (sr.color.a < 0)
Destroy(gameObject);//当透明度小于等于0时销毁克隆体
}
}
public void SetupClone(Transform _newTransform, float _cloneDuration, bool _canAttack, Vector3 _offset, Transform _closetEnemy,bool _canDuplicate,float _chanceToDuplicate,Player _player)
{
if (_canAttack)
{
anim.SetInteger("AttackNumber", Random.Range(1, 3));//随机clone攻击的动画
}
//Debug.Log($"Setting clone position to: {_newTransform.position}");
player = _player;
transform.position = _newTransform.position + _offset;//将克隆体的位置设置为传入的位置
cloneTimer = _cloneDuration;//设置克隆体的持续时间
closestEnemy = _closetEnemy;
canDuplicateClone = _canDuplicate;
chanceToDuplicate = _chanceToDuplicate;
FaceClosestTarget();
}
private void AnimationTrigger()
{
cloneTimer = -.1f;
}
private void AttackTrigger()//攻击碰撞触发函数
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(attackCheck.position, attackCheckRadius);//这行代码在 Unity 中用于检测一个圆形区域内的所有碰撞体,并返回它们的数组。
foreach (var hit in colliders)//for循环遍历碰撞体数组
{
if (hit.GetComponent<Enemy>() != null)
{
player.stats.DoDamage(hit.GetComponent<CharacterStats>());
//hit.GetComponent<Enemy>().DamageImpact();
if (canDuplicateClone)//如果可以多重影分身
{
if (Random.Range(0, 100) <= chanceToDuplicate)
{
SkillManager.instance.clone.CreateClone(hit.transform,new Vector3(.5f*facingDir,0));//在敌人身上创建克隆
}
}
}
}
}
private void FaceClosestTarget()//面对最近的目标函数
{
if (closestEnemy != null)
{
if (transform.position.x > closestEnemy.position.x)
{
facingDir = -1;
transform.Rotate(0, 180, 0);
}
}
}
}
SwordSkill仍刀技能组
Sword_Skill
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//P67仍刀技能
public enum SwordType//刀的类型,枚举(enum)是一种特殊的数据类型,它允许你为一组相关的常量赋予有意义的名称。这样可以提高代码的可读性和可维护性。
{
Regular,//常规
Bounce,//反弹
Pierce,//穿透
Spin//旋转
}
public class Sword_Skill : Skill
{
public SwordType swordType = SwordType.Regular;//刀的类型
[Header("Bounce info")]
[SerializeField] private int bounceAmount;//反弹次数
[SerializeField] private float bounceGravity;//反弹速度
[SerializeField] private float bounceSpeed;
[Header("Peirce info")]
[SerializeField] private int pierceAmount;//穿透次数
[SerializeField] private float pierceGravity;//穿透速度
[Header("Spin info")]
[SerializeField] private float hitCooldown = .35f;//击中冷却
[SerializeField] private float maxTravelDistance = 7;//最大旋转距离
[SerializeField] private float spinDuration = 2;//旋转持续时间
[SerializeField] private float spinGravity = 1;//旋转重力
[Header("Skill info")]
[SerializeField] private GameObject swordPrefab;//飞行物体
[SerializeField] private Vector2 launchForce;//飞行方向
[SerializeField] private float swordGravity;//飞行重力
[SerializeField] private float freezeTimeDuration;//冻结时间
[SerializeField] private float returnSpeed ;
private Vector2 finalDir;
[Header("Anim dots")]
[SerializeField] private int numberOfDots;
[SerializeField] private float spaceBetweenDots;
[SerializeField] private GameObject dotPrefab;
[SerializeField] private Transform dotsParent;
private GameObject[] dots;
protected override void Start()
{
base.Start();
GenerateDots();
SetupGravity();
}
public void SetupGravity()
{
if (swordType == SwordType.Bounce)
swordGravity = bounceGravity;
else if (swordType == SwordType.Pierce)
swordGravity = pierceGravity;
else if (swordType == SwordType.Spin)
swordGravity = spinGravity;
}
protected override void Update()
{
if (Input.GetKeyUp(KeyCode.Mouse1))
finalDir = new Vector2(AimDirection().normalized.x * launchForce.x, AimDirection().normalized.y * launchForce.y);
if (Input.GetKey(KeyCode.Mouse1))
{
for (int i = 0; i < dots.Length; i++)
{
dots[i].transform.position = DotsPosition(i * spaceBetweenDots);
}
}
}
public void CreateSword()
{
GameObject newSword = Instantiate(swordPrefab, player.transform.position, transform.rotation);//获取物体,位置,旋转,它可以根据现有的预制件(Prefab)、场景中的对象或其他资源来生成新的实例
Sword_Skill_Controller newSwordScript = newSword.GetComponent<Sword_Skill_Controller>();
if (swordType == SwordType.Bounce)
newSwordScript.SetupBounce(true, bounceAmount, bounceSpeed);
else if (swordType == SwordType.Pierce)
newSwordScript.SetupPierce(pierceAmount);
else if (swordType == SwordType.Spin)
newSwordScript.SetupSpin(true, maxTravelDistance, spinDuration, hitCooldown);
newSwordScript.SetupSword(finalDir, swordGravity, player,freezeTimeDuration, returnSpeed);
player.AssignNewSword(newSword);
DotsActive(false);
}
#region Aim region
public Vector2 AimDirection()//瞄准方向
{
Vector2 playerPosition = player.transform.position;
Vector2 mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2 direction = mousePosition - playerPosition;//两者相减就是瞄准方向
return direction;
}
public void DotsActive(bool _isActive)
{
for (int i = 0; i < dots.Length; i++)
{
dots[i].SetActive(_isActive);
}
}
private void GenerateDots()
{
dots = new GameObject[numberOfDots];
for (int i = 0; i < numberOfDots; i++)
{
dots[i] = Instantiate(dotPrefab, player.transform.position, Quaternion.identity, dotsParent);
dots[i].SetActive(false);
}
}
private Vector2 DotsPosition(float t)//传入顺序相关的点间距
{
Vector2 position = (Vector2)player.transform.position + new Vector2
(AimDirection().normalized.x * launchForce.x,
AimDirection().normalized.y * launchForce.y) * t + .5f * (Physics2D.gravity * swordGravity) * (t * t);
//t是控制之间点间距的
return position;//返回位置
}//设置点间距函数
#endregion
}
Sword_Skill_Controller
using System.Collections.Generic;
using UnityEngine;
public class Sword_Skill_Controller : MonoBehaviour
{
private Animator anim;
private Rigidbody2D rb;
private CircleCollider2D cd;
private Player player;
private bool canRotate = true;
private bool isReturning;
private float freezeTimeDUration;
private float returnSpeed = 12;
[Header("Pierce info")]
[SerializeField] private int pierceAmount;
[Header("Bounce info")]
private float bounceSpeed;// 想通过函数传递删除SerializeField
private bool isBouncing; // 是否可以反弹
private int bounceAmount;// 反弹次数
private List<Transform> enemyTarget;//敌人目标
private int targetIndex = 0;//目标索引
[Header("Spin info")]
private float maxTravelDistance;//最大旋转距离
private float spinDuration;//旋转持续时间
private float spinTimer;//旋转计时器
private bool wasStopped;//是否停止
private bool isSpinning;//是否旋转
private float hitTimer;
private float hitCooldown;
private float spinDirection;//旋转方向
//Awake在脚本实例化时立即调用。它在所有对象的Awake方法都被调用完毕后,才会开始调用Start方法。而Start在第一次更新循环之前调用。
private void Awake()
{
anim = GetComponentInChildren<Animator>();
rb = GetComponent<Rigidbody2D>();
cd = GetComponent<CircleCollider2D>();
}
private void DestroyMe()
{
Destroy(gameObject);
}
//以下四个函数都是把局部变量传递给全局变量
public void SetupSword(Vector2 _dir, float _gravityScale, Player _player,float _freezeTimeDUration,float _returnSpeed) //设置飞行物体
{
player = _player;
freezeTimeDUration = _freezeTimeDUration;
returnSpeed = _returnSpeed;
rb.velocity = _dir;
rb.gravityScale = _gravityScale;
if (pierceAmount <= 0)
anim.SetBool("Rotation", true);
spinDirection = Mathf.Clamp(rb.velocity.x, -1, 1);//限制旋转方向在-1到1之间
Invoke("DestroyMe", 7);//Invoke 是 Unity 中 MonoBehaviour 类的一部分,用于在指定的延迟时间后调用某个方法
}
public void SetupBounce(bool _isBouncing, int _amountOfBounces, float _bounceSpeed)//设置反弹
{
isBouncing = _isBouncing;
bounceAmount = _amountOfBounces;
bounceSpeed = _bounceSpeed;
enemyTarget = new List<Transform>();//当把上面的public改成private时,系统就不会创建一个空的列表
}
public void SetupPierce(int _pierceAmount)//int _pierceAmoun:方法参数
{
pierceAmount = _pierceAmount;
}
public void SetupSpin(bool _isSpinning, float _maxTravelDistance, float _spinDuration, float _hitCooldown)//设置旋转
{
isSpinning = _isSpinning;
maxTravelDistance = _maxTravelDistance;
spinDuration = _spinDuration;//,_spinDuration 是一个形式参数
hitCooldown = _hitCooldown;
}
public void ReturnSword()
{
rb.constraints = RigidbodyConstraints2D.FreezeAll;// 冻结刚体的所有约束
//rb.isKinematic = false;
transform.parent = null;
isReturning = true;
}
private void Update()
{
if (canRotate)//如果可以旋转
transform.right = rb.velocity;//设置旋转方向
if (isReturning)
{
transform.position = Vector2.MoveTowards(transform.position, player.transform.position, returnSpeed * Time.deltaTime);//返回到玩家手上
if (Vector2.Distance(transform.position, player.transform.position) < 1)
player.CatchTheSword();
}
BounceLogic();//反弹逻辑
SpinLogic();//旋转逻辑
}
private void SpinLogic()
{
if (isSpinning)
{
if (Vector2.Distance(transform.position, player.transform.position) > maxTravelDistance && !wasStopped)//如果距离大于最大旋转距离并且没有停止
{
StopWhenSpinning();
}
if (wasStopped)//如果停止
{
spinTimer -= Time.deltaTime;//计时器减去时间
transform.position = Vector2.MoveTowards(transform.position,
new Vector2(transform.position.x + spinDirection, transform.position.y), 1.5f * Time.deltaTime);//移动到旋转方向
if (spinTimer < 0)
{
isReturning = true;
isSpinning = false;
}
hitTimer -= Time.deltaTime;
if (hitTimer < 0)
{
hitTimer = hitCooldown;
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, 1);
foreach (var hit in colliders)
{
if (hit.GetComponent<Enemy>() != null)
{
SwordSkillDamage(hit.GetComponent<Enemy>());
}
}
}
}
}
}
private void StopWhenSpinning()//旋转时候停止
{
wasStopped = true;
rb.constraints = RigidbodyConstraints2D.FreezeAll;
spinTimer = spinDuration;//旋转计时器
}
private void BounceLogic()
{
if (isBouncing && enemyTarget.Count > 0)//如果可以反弹并且敌人目标数量大于0
{
transform.position = Vector2.MoveTowards(transform.position, enemyTarget[targetIndex].position, bounceSpeed * Time.deltaTime);//移动到敌人
if (Vector2.Distance(transform.position, enemyTarget[targetIndex].position) < 0.1f)//如果距离小于0.1
{
SwordSkillDamage(enemyTarget[targetIndex].GetComponent<Enemy>());//敌人受到伤害
//enemyTarget[targetIndex].GetComponent<Enemy>().Damage();
//enemyTarget[targetIndex].GetComponent<Enemy>().StartCoroutine("FreezeTimerFor", freezeTimeDUration);
targetIndex++; //敌人目标的索引,攻击了这个敌人就攻击下一个敌人
bounceAmount--;
if (bounceAmount <= 0)
{
isBouncing = false;
isReturning = true;
}
if (targetIndex >= enemyTarget.Count) //如果目标索引大于等于敌人目标数量
{
targetIndex = 0;
}
}
}
}
private void OnTriggerEnter2D(Collider2D collision)//Sword碰到敌人时候的处理
{
if (isReturning)
return;//后面的就不会再触发,sword可以返回时候攻击到敌人,并且返回到手上
if(collision.GetComponent<Enemy>() != null)//如果碰到敌人
{
Enemy enemy = collision.GetComponent<Enemy>();//获取敌人
SwordSkillDamage(enemy);
}
SetupTargetsForBounce(collision);
StuckInto(collision);
}
private void SwordSkillDamage(Enemy enemy)
{
//enemy.DamageEffect();
player.stats.DoDamage(enemy.GetComponent<CharacterStats>());
enemy.StartCoroutine("FreezeTimerFor", freezeTimeDUration);
}
private void SetupTargetsForBounce(Collider2D collision)
{
if (collision.GetComponent<Enemy>() != null)//碰到敌人
{
if (isBouncing && enemyTarget.Count <= 0)//如果可以反弹并且敌人目标数量小于等于0
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, 10);//获取周围敌人的碰撞体
foreach (var hit in colliders)//遍历周围敌人的碰撞体
{
if (hit.GetComponent<Enemy>() != null)//如果碰到的是敌人
{
enemyTarget.Add(hit.transform);//添加到敌人目标
}
}
}
}
}
private void StuckInto(Collider2D collision)//碰撞时候的处理
{
if (pierceAmount > 0 && collision.GetComponent<Enemy>() != null)//如果可以穿透并且碰到敌人
{
pierceAmount--;
return;
}
if (isSpinning)
{
StopWhenSpinning();//注释掉经过敌人不会停止
return;
}
canRotate = false; // 停止旋转
cd.enabled = false;// 禁用碰撞体
rb.isKinematic = true;// 设置刚体为运动学模式
rb.constraints = RigidbodyConstraints2D.FreezeAll;// 冻结刚体的所有约束
if (isBouncing && enemyTarget.Count > 0) // 如果可以反弹并且敌人目标数量大于0
return;
anim.SetBool("Rotation", false);
transform.parent = collision.transform;// 将当前物体设为碰撞对象的子对象,即粘在敌人身上
}
}
Blackhole黑洞技能
Blackhole_Skill
using UnityEngine;
public class Blackhole_Skill : Skill
{
[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;//当前的黑洞
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,传递一系列参数来配置黑洞的行为,包括最大尺寸、增长速度、缩小速度、攻击次数和克隆冷却时间
}
protected override void Start()
{
base.Start();
}
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;
}
}
BlackHole_Skill_Controller
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_HotKey_Controller
using TMPro;
using UnityEngine;
//TextMeshPro 是 Unity 中一个高级文本渲染插件,提供了比 Unity 内置的 UI.Text 更强大的文本渲染功能。它主要用于在游戏和应用程序中显示高质量的文本
public class Blackhole_HotKey_Controller : MonoBehaviour
{
private SpriteRenderer sr;
private KeyCode myHotKey;
private TextMeshProUGUI myText;
private Transform myEnemy;
private BlackHole_Skill_Controller blackHole;//
public void SetupHotKey(KeyCode _myNewHotKey, Transform _myEnemy, BlackHole_Skill_Controller _myBlackHole)
{
sr = GetComponent<SpriteRenderer>();
myText = GetComponentInChildren<TextMeshProUGUI>();
myEnemy = _myEnemy;
blackHole = _myBlackHole;
myHotKey = _myNewHotKey;
myText.text = _myNewHotKey.ToString();//将按键转换为字符串
}
private void Update()
{
if (Input.GetKeyDown(myHotKey))
{
blackHole.AddEnemyToList(myEnemy);
myText.color = Color.clear;
sr.color = Color.clear;
}
}
}
Crystal水晶技能
Crystal_Skill
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//10月25日,有一个使用多重水晶无法进入冷却的Bug
public class Crystal_Skill : Skill //放在技能控制器里面
{
[SerializeField] private float crystalDuration;
[SerializeField] private GameObject crystalPrefab;
private GameObject currentCrystal;//预制件创建得临时水晶
[Header("Crystal mirage")]
[SerializeField] private bool cloneInsteadOfCrystal;//克隆代替水晶
[Header("Explosive crystal")]
[SerializeField] private bool canExplode;
[Header("Moving crystal")]
[SerializeField] private bool canMoveToEnemy;
[SerializeField] private float moveSpeed;
[Header("Multi stacking crystal")]//水晶堆栈
[SerializeField] private bool canUseMultiStacks;
[SerializeField] private int amountOfStacks;
[SerializeField] private float multiStackCooldown;
[SerializeField] private float useTimerWindow;
[SerializeField] private List<GameObject> crystalLeft = new List<GameObject>(); //堆栈使用的列表
public override bool CanUseSkill()
{
return base.CanUseSkill();
}
public override void UseSkill()
{
base.UseSkill();
if (CanUseMultiStack())
return;
if (currentCrystal == null)//如果没有水晶
{
CreateCrystal();
}
else
{
if (canMoveToEnemy)//有水晶的情况下,如果可以移动到敌人
return;
Vector2 playerPos = player.transform.position;//先保存玩家位置
player.transform.position = currentCrystal.transform.position;//飞雷神之术
currentCrystal.transform.position = playerPos;//位置互换
if(cloneInsteadOfCrystal)//如果是克隆代替水晶
{
SkillManager.instance.clone.CreateClone(currentCrystal.transform, Vector3.zero);
Destroy(currentCrystal);
}
else
{
currentCrystal.GetComponent<Crystal_Skill_Controller>().FinishCrystal();
}
}
}
public void CreateCrystal()
{
currentCrystal = Instantiate(crystalPrefab, player.transform.position, Quaternion.identity);//运行技能如果水晶没有那就创建一个
Crystal_Skill_Controller currentCysalScrit = currentCrystal.GetComponent<Crystal_Skill_Controller>();//获得控制器中的组件
currentCysalScrit.SetupCrystal(crystalDuration, canExplode, canMoveToEnemy, moveSpeed, FindClosesetEnemy(currentCrystal.transform), player);//设置水晶函数
//currentCysalScrit.ChooseRandomEnemy();
}
public void CurrentCrystalChooseRandomTarget() => currentCrystal.GetComponent<Crystal_Skill_Controller>().ChooseRandomEnemy();
private bool CanUseMultiStack()//是否可以使用多个水晶
{
if (canUseMultiStacks)
{
if(crystalLeft.Count > 0 )
{
if(crystalLeft.Count == amountOfStacks)
Invoke("ResetAbility", useTimerWindow);
cooldown = 0;
GameObject crystalToSpawn = crystalLeft[crystalLeft.Count - 1];//在列表中找到最后一个水晶
GameObject newCrystal = Instantiate(crystalToSpawn, player.transform.position, Quaternion.identity);//创建一个新的水晶
crystalLeft.Remove(crystalToSpawn);
newCrystal.GetComponent<Crystal_Skill_Controller>().
SetupCrystal(crystalDuration, canExplode, canMoveToEnemy, moveSpeed, FindClosesetEnemy(newCrystal.transform), player);//调用放置函数
if(crystalLeft.Count <= 0)
{
cooldownTimer = multiStackCooldown;
RefilCrystal();
}
return true;
}
}
return false;
}
private void RefilCrystal()//重新填充水晶函数
{
int amountToAdd = amountOfStacks - crystalLeft.Count;
for (int i = 0; i < amountToAdd; i++)//总是补充到3个
{
crystalLeft.Add(crystalPrefab);
}
}
private void ResetAbility()
{
if (cooldownTimer > 0)
return;
cooldownTimer = multiStackCooldown;
RefilCrystal();
}
}
Crystal_Skill_Controller
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Crystal_Skill_Controller : MonoBehaviour //放在水晶得预制件里面
{
private Animator anim => GetComponent<Animator>(); //引用是为了在更新中使用SetTrigger
private CircleCollider2D cd => GetComponent<CircleCollider2D>();//为了完成爆炸伤害
private Player player;// 2024年10月30日,给技能加上伤害
private float crystalExistTimer;//消失计时器
private bool canExplode ;//是否可以爆炸
private bool canMove;
private float moveSpeed;
private bool canGrow;
private float growSpeed = 5;
private Transform closetTarget;
[SerializeField] private LayerMask whatIsEnemy;
public void SetupCrystal(float _crystalDuration,bool _canExplode,bool _canMove,float _moveSpeed,Transform _closetTarget,Player _player)
{
player = _player;
crystalExistTimer = _crystalDuration;//放置水晶,然后开始计时
canExplode = _canExplode;
canMove = _canMove;
moveSpeed = _moveSpeed;
closetTarget=_closetTarget;
}
public void ChooseRandomEnemy()
{
float radius = SkillManager.instance.blackhole.GetBlackholeRadius();//从黑洞控制器中获取黑洞半径
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, radius, whatIsEnemy);//选取周围所有的碰撞体
if(colliders.Length > 0)
closetTarget = colliders[Random.Range(0, colliders.Length)].transform;//随机选取一个敌人
}
private void Update()
{
crystalExistTimer -= Time.deltaTime;//控制器起码能控制时间吧
if (crystalExistTimer < 0)
{
//Destroy(gameObject); 新增的功能,水晶消失后可以爆炸,所以检查是否可以爆炸
FinishCrystal();
}
if (canMove)//移动到敌人的逻辑函数
{
transform.position = Vector2.MoveTowards(transform.position, closetTarget.position, moveSpeed * Time.deltaTime);//水晶移动到敌人位置(这里是最近敌人位置)
if (Vector2.Distance(transform.position, closetTarget.position) < .5f)//如果水晶到达敌人位置
{
FinishCrystal();
canMove = false;
}
}
if (canGrow)//和上面函数优先级?
transform.localScale = Vector2.Lerp(transform.localScale, new Vector2(3,3), growSpeed * Time.deltaTime);//水晶变大
}
private void AnimationExplodeEvent()//可以放在动画触发器里面
{
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, cd.radius);//从克隆控制器粘贴上的
foreach (var hit in colliders)
{
if (hit.GetComponent<Enemy>() != null)
player.stats.DoMagicDamage(hit.GetComponent<CharacterStats>());//加上魔法伤害
}
}
public void FinishCrystal()
{
if (canExplode)
{
canGrow = true;
anim.SetTrigger("Explode");
}
else
SelfDestroy();
}
public void SelfDestroy() => Destroy(gameObject);
}
ShockStrike雷击技能
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ShockStrike_Controller : MonoBehaviour
{
[SerializeField] private CharacterStats targetStats;
[SerializeField] private float speed;
private int damage;
private Animator anim;
private bool triggered;
void Start()
{
anim=GetComponentInChildren<Animator>();
}
public void Setup(int _damage,CharacterStats _targetStats)
{
damage = _damage;
targetStats = _targetStats;
}
void Update()
{
if (!targetStats)//没有目标数据就不会发挥作用
return;
if (triggered)
return;
transform.position = Vector2.MoveTowards(transform.position, targetStats.transform.position, speed * Time.deltaTime);//移动到目标位置
transform.right = transform.position - targetStats.transform.position;//面向目标位置
if (Vector2.Distance(transform.position, targetStats.transform.position) < .1f)//碰到敌人
{
anim.transform.localPosition = new Vector3(0, .5f);
anim.transform.localRotation = Quaternion.identity;// Quaternion.identity 表示没有旋转
transform.localRotation = Quaternion.identity;
transform.localScale = new Vector3(3, 3);//缩放
Invoke("DamageAndSelfDestroy", .2f);
triggered = true;
anim.SetTrigger("Hit");
}
}
private void DamageAndSelfDestroy()
{
targetStats.ApplyShock(true);
targetStats.TakeDamage(1);
Destroy(gameObject, .4f);
}
}
849



被折叠的 条评论
为什么被折叠?



