devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity2d平台动作游戏教程_physics2d.overlapcircle

作者：Gausst松鼠会 | 2024-02-16 04:25:45

赞

踩

physics2d.overlapcircle

最终效果如下：

目录

玩家的基础移动

加入移动和跳跃动画

加入攻击动作

实现打击感

添加敌人受击动画与击退

添加敌人受击特效

 攻击时的屏幕振动

首先实现最基础的功能，将环境拖拽进来，注意到环境的各个前后景的层次感是通过设定layer实现的：

 

玩家的基础移动

我们将玩家设定在第七个layer，以便于突出玩家处于环境中间。

并为了跳跃手感改变重力scale，这可以实现重力对不同的物体有不同的效果。

下面这段代码实现了移动和跳跃

  1. public class MyPlayerController : MonoBehaviour
  2. {
  3.     new private Rigidbody2D rigidbody;
  4.     private float input;
  5.     private bool isGround;
  6.  
  7.     [SerializeField]
  8.     public Vector3 checkPointOffset;
  9.  
  10.     [SerializeField]
  11.     public LayerMask groundLayer;
  12.  
  13.     public int moveSpeed = 10;
  14.     public int jumpStartSpeed = 10;
  15.     // Start is called before the first frame update
  16.     void Start()
  17.     {
  18.         rigidbody = GetComponent<Rigidbody2D>();
  19.  
  20.     }
  21.  
  22.     // Update is called once per frame
  23.     void Update()
  24.     {
  25.         input = Input.GetAxisRaw("Horizontal");
  26.         isGround = Physics2D.OverlapCircle(transform.position + new Vector3(checkPointOffset.x, checkPointOffset.y, 0), checkPointOffset.z, groundLayer);
  27.         Move();
  28.  
  29.     }
  30.  
  31.     void Move()
  32.     {
  33.         rigidbody.velocity = new Vector2(input * moveSpeed, rigidbody.velocity.y);
  34.         if (Input.GetKeyDown(KeyCode.W) && isGround)
  35.         {
  36.             rigidbody.velocity = new Vector2(0, jumpStartSpeed);
  37.         }
  38.  
  39.         if (rigidbody.velocity.x < 0)
  40.             transform.localScale = new Vector3(-1, 1, 1);
  41.         else if (rigidbody.velocity.x > 0)
  42.             transform.localScale = new Vector3(1, 1, 1);
  43.     }
  44. }

这两个标头具有序列化的作用：

 

 

加入移动和跳跃动画

exit time打断时间（从哪一帧开始逐渐降低当前动画的权重）、

fixed duration固定持续时间（这其实是一个切换开关，切换是按照秒显示还是按照百分比显示）、transition duration过度持续时间 （过度有多长）、

勾选这个选项其实影响的是以百分比还是秒来显示：

transition offset过度抵消（从下一个动画的什么位置开始播放）、

interruption source中断来源 

先创建控制器并且拖入站立和跑步和跳跃的动画，并进行衔接：

同时删去过渡时间：

在动画控制器中 如果动画切换的条件是用一个与来表示的话 可以这样：

（注意对于速度的设置判断有时候不要判断是否为0，因为有时候即使没动，物体的速度可能也是一个非常小的值：

）

如果是用或条件表示的话，就多添加一次transtition，就会变成下图所示：

 此处举例，从站立到跑有两个切换条件

 

 jump的切换使用触发器：

随后即可实现跑跳

接下来加入降落的动画，即人物到达最高点后，会播放降落的动画：

三种状态都有可能进入fall状态，因此进行设置

 为了降落更加流畅，给Fall添加一个无条件的falling动画，之后动画变成这样：

之后即可实现降落。

接下来实现着陆地面，由于着陆到地面有三种前置可能：jump、fall、falling，因此都需要添加转换。并且落地后无条件变为idle，如下所示：

 让玩家着陆1秒后变为idle状态：

实现如下：

 

此时代码如下：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class MyPlayerController : MonoBehaviour
  6. {
  7.     new private Rigidbody2D rigidbody;
  8.     private float input;
  9.     private bool isGround;
  10.     [SerializeField]
  11.     public Vector3 checkPointOffset;
  12.     [SerializeField]
  13.     public LayerMask groundLayer;
  14.     public int moveSpeed = 5;
  15.     public int jumpStartSpeed = 10;
  16.  
  17.     //----------下面这部分实现动画
  18.     private Animator animator;
  19.  
  20.  
  21.     // Start is called before the first frame update
  22.     void Start()
  23.     {
  24.         rigidbody = GetComponent<Rigidbody2D>();
  25.         animator = GetComponent<Animator>();
  26.     }
  27.  
  28.     // Update is called once per frame
  29.     void Update()
  30.     {
  31.         input = Input.GetAxisRaw("Horizontal");
  32.         isGround = Physics2D.OverlapCircle(transform.position + new Vector3(checkPointOffset.x, checkPointOffset.y, 0), checkPointOffset.z, groundLayer);
  33.         Move();
  34.  
  35.     }
  36.  
  37.     void Move()
  38.     {
  39.         rigidbody.velocity = new Vector2(input * moveSpeed, rigidbody.velocity.y);
  40.         animator.SetFloat("Horizontal", rigidbody.velocity.x);
  41.         animator.SetFloat("Vertical", rigidbody.velocity.y);
  42.  
  43.         animator.SetBool("isGround", isGround);
  44.         if (Input.GetKeyDown(KeyCode.W) && isGround)
  45.         {
  46.             rigidbody.velocity = new Vector2(0, jumpStartSpeed);
  47.             animator.SetTrigger("Jump");
  48.         }
  49.  
  50.         if (rigidbody.velocity.x < 0)
  51.             transform.localScale = new Vector3(-1, 1, 1);
  52.         else if (rigidbody.velocity.x > 0)
  53.             transform.localScale = new Vector3(1, 1, 1);
  54.  
  55.  
  56.         
  57.  
  58.     }
  59. }

加入攻击动作

首先导入资源，加入三个轻攻击动画到动画机里，由于希望任何状态都可以攻击，所以用any state衔接：

设置好过度条件

并且播放完攻击动画希望玩家再次进入idle，因此可以将过度衔接到exit：

重攻击同理，随后效果如下：

接下来书写Attack函数：

  1.  
  2.     private int lightCombo = 1;
  3.     private int heavyCombo = 1;
  4.     private int comboInterval = 2;//连击的间隔，一旦超过这个间隔则玩家连击会中断
  5.     private float comboTimer = 0;//连击计时器，用来记录连击到上次过了多久
  6.     bool isAttack = false;    
  7.  
  8.     void Attack()
  9.     {
  10.         if (!isAttack && Input.GetKeyDown(KeyCode.J))
  11.         {
  12.             isAttack = true;
  13.             animator.SetTrigger("LightAttack");
  14.             animator.SetInteger("LightCombo", lightCombo);
  15.             lightCombo++;
  16.             if (lightCombo > 3) lightCombo = 1;
  17.             comboTimer = 0;
  18.         }
  19.         if (!isAttack && Input.GetKeyDown(KeyCode.K))
  20.         {
  21.             isAttack = true;
  22.             animator.SetTrigger("HeavyAttack");
  23.             animator.SetInteger("HeavyCombo", heavyCombo);
  24.             heavyCombo++;
  25.             if (heavyCombo > 3) heavyCombo = 1;
  26.             comboTimer = 0;
  27.         }
  28.  
  29.             comboTimer += Time.deltaTime;
  30.             if (comboTimer >= comboInterval)
  31.             {
  32.                 comboTimer = 0;
  33.                 lightCombo = 0;
  34.                 heavyCombo = 0;
  35.             }
  36.  
  37.  
  38.     }

以及一个attackOver函数，用于函数结束时调用：

  1.     public void AttackOver()//用来给unity在动画结束时调用，采用帧事件的形式
  2.     {
  3.         isAttack = false;
  4.     }

接下来添加帧事件，在动画播放完关键连击时插入关键帧，用于调用attackover函数。

通常这种关键帧不会放在动画的最后一帧，这样有助于连击的连贯性。 

但是我们发现攻击时仍可以移动，我们需要取消这点，取而代之，使用攻击时自动位移的方式实现位移补偿。

  1.     private string attackType;
  2.     [Header("补偿速度")]
  3.     public float lightAttackSpeed=1.3f;
  4.     public float heavyAttackSpeed=0.7f;    
  5.     void Move()
  6.     {
  7.         if (!isAttack) {
  8.             rigidbody.velocity = new Vector2(input * moveSpeed, rigidbody.velocity.y);
  9.         }
  10.         else
  11.         {
  12.             if(attackType=="Light") rigidbody.velocity = new Vector2(transform.localScale.x * lightAttackSpeed, rigidbody.velocity.y);
  13.             if (attackType == "Heavy") rigidbody.velocity = new Vector2(transform.localScale.x * heavyAttackSpeed, rigidbody.velocity.y);
  14.  
  15.         }
  16.  
  17.     }

此处代码犯了一个错，清空连击应该设置为1而不是设置为0：

此处还犯了一个bug，bug动图如下：如果在移动中按下攻击键，则玩家不会立即进入攻击状态而是跑一小段距离再进入攻击，如果把衔接的has exit time移除即可。

在实际上自己做这一步的时候一下子犯了两个bug，以后也可能会出现一下子遇见多个bug的情况。

解决bug的思路其实很简单，重点观察那些参数，检查代码是否有误，无误则检查是否是动画器某个衔接设置错了。

实现打击感

添加敌人受击动画与击退

我们接下来添加敌人，并为玩家的layer设置为player，敌人的layer设置为enemy，并且我们不希望player和enemy发生碰撞，因此在设置中选择：

为敌人添加动画控制器：

 

 接下来需要在攻击动画的对应时刻进行攻击范围的判定，因此需要加特定的因素然后在特定帧修改，通过录制动画的形式。

 

加好之后，接下来书写代码：

给玩家添加attackArea后，注意层级不能设置为player否则无法发生触碰。

触碰敌人的代码：

  1.     private void OnTriggerEnter2D(Collider2D other)
  2.     {
  3.         if (other.CompareTag("Enemy"))
  4.         {
  5.             if (transform.localScale.x > 0) other.GetComponent<MyEnemy>().GetHit(Vector2.right);
  6.             if (transform.localScale.x < 0) other.GetComponent<MyEnemy>().GetHit(Vector2.left);
  7.             Debug.Log("attack success");
  8.         }
  9.     }

Enemy的函数：

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class MyEnemy : MonoBehaviour
  6. {
  7.     private new Rigidbody2D rigidbody;
  8.     private bool isHit;
  9.  
  10.     private Animator animator;
  11.     private AnimatorStateInfo animStateInfo;
  12.     public float speed;
  13.     private Vector2 direction;
  14.     // Start is called before the first frame update
  15.     void Start()
  16.     {
  17.         animator = GetComponent<Animator>();
  18.         rigidbody = GetComponent<Rigidbody2D>();
  19.  
  20.     }
  21.  
  22.     // Update is called once per frame
  23.     void Update()
  24.     {
  25.         animStateInfo = animator.GetCurrentAnimatorStateInfo(0);
  26.         if (isHit)
  27.         {
  28.             rigidbody.velocity = direction * speed;
  29.             if (animStateInfo.normalizedTime > 0.6f)//敌人后退的时间
  30.             {
  31.                 isHit = false;
  32.             }
  33.         }
  34.     }
  35.  
  36.     public void GetHit(Vector2 direction)//公开的给玩家调用的函数
  37.     {
  38.         transform.localScale = new Vector3(-direction.x, 1, 1);//与玩家的方向相反
  39.         isHit = true;
  40.         this.direction = direction;//让敌人按照玩家朝向的方向后退
  41.         animator.SetTrigger("Hit");
  42.     }
  43. }

效果如下

添加敌人受击特效

为敌人添加子物体，并为其创建帧动画，帧动画由特效组成：

然后设置动画器：

 在enemy脚本中添加：

效果如下：

 攻击时的屏幕振动

此处希望这个类作为工具类，让其他脚本方便的调用里面的函数，所以这里采用单例模式编写，可以直接调用其方法而无需实例化。

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class AttackShake : MonoBehaviour
  6. {
  7.     private static AttackShake instance;
  8.     public static AttackShake Instance
  9.     {
  10.         get
  11.         {
  12.             if (instance == null)
  13.                 instance = Transform.FindObjectOfType<AttackShake>();
  14.             return instance;
  15.         }
  16.     }
  17.  
  18.     public void HitPause(int duration)
  19.     {
  20.         StartCoroutine(Pause(duration));
  21.     }
  22.     IEnumerator Pause(int duration)
  23.     {
  24.         float pauseTime = duration / 60f;
  25.         Time.timeScale = 0;//暂时暂停时间
  26.         yield return new WaitForSecondsRealtime(pauseTime);
  27.         Time.timeScale = 1;
  28.     }
  29.     private bool isShake;
  30.     public void CameraShake(float duration,float strength)
  31.     {
  32.         if (!isShake) StartCoroutine(Shake(duration, strength));
  33.     }
  34.     IEnumerator Shake(float duration,float strength)
  35.     {
  36.         isShake = true;
  37.         Transform camera = Camera.main.transform;
  38.         Vector3 startPos = camera.position;
  39.         while (duration > 0)
  40.         {
  41.             camera.position = Random.insideUnitSphere * strength+startPos;
  42.             duration -= Time.deltaTime;
  43.             yield return null;
  44.         }
  45.         isShake = false;
  46.     }
  47. }

上面实现了卡顿和抖动的函数，接下来只需要让玩家命中敌人时调用该函数并传入参数即可。

在playerController中：

  1.  
  2.     [Header("打击感")]
  3.     public float shakeTime=0.1f;
  4.     public int lightPause = 6;
  5.     public float lightStrength=0.015f;
  6.     public int heavyPause=12;
  7.     public float heavyStrength=0.065f;
  8.  
  9.     private void OnTriggerEnter2D(Collider2D other)
  10.     {
  11.         if (other.CompareTag("Enemy"))
  12.         {
  13.             if (transform.localScale.x > 0) other.GetComponent<MyEnemy>().GetHit(Vector2.right);
  14.             if (transform.localScale.x < 0) other.GetComponent<MyEnemy>().GetHit(Vector2.left);
  15.             Debug.Log("attack success");
  16.  
  17.             if (attackType == "Light")
  18.             {
  19.                 AttackShake.Instance.HitPause(lightPause);
  20.                 AttackShake.Instance.CameraShake(shakeTime, lightStrength);
  21.             }
  22.             if (attackType == "Heavy")
  23.             {
  24.                 AttackShake.Instance.HitPause(heavyPause);
  25.                 AttackShake.Instance.CameraShake(shakeTime, heavyStrength);
  26.             }
  27.         }
  28.     }

然后根据攻击类型是轻重攻击调用不同的参数即可，最终效果如下：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/90693
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号