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

Unitask学习记录-附工程文件

作者：花生_TL007 | 2024-02-15 22:07:10

赞

踩

Unitask学习记录-附工程文件

工程文件下载

  1. using Cysharp.Threading.Tasks;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using UnityEngine;
  5. using UnityEngine.UI;
  6. using UnityEngine.Networking;
  7. using UnityEngine.SceneManagement;
  8.  
  9. public class UniTaskTest : MonoBehaviour
  10. {
  11.     private UniTaskSys uniTaskSys;
  12.  
  13.     public Image img_Test;
  14.  
  15.     //百度一张图片：右击，在新标签页中打开图像，复制url
  16.     private string url;
  17.  
  18.     private bool isO_Down;
  19.     private bool isP_Down;
  20.  
  21.     private void Awake()
  22.     {
  23.         uniTaskSys = new UniTaskSys();
  24.         url = "https://n.sinaimg.cn/sinacn18/600/w1920h1080/20180508/2a45-haichqy4087272.jpg";
  25.     }
  26.  
  27.     private void Start()
  28.     {
  29.         //AsyncLoadTextAsset("1");
  30.         LoadScene("Demo");
  31.         //AsyncWebRequestTexture(url);
  32.  
  33.         //uniTaskSys.DelayTest(this);
  34.         WhenAllTest();
  35.         WhenAnyTest();
  36.     }
  37.  
  38.     private void Update()
  39.     {
  40.         if (Input.GetKeyDown(KeyCode.O))
  41.         {
  42.             isO_Down = true;
  43.         }
  44.         if (Input.GetKeyDown(KeyCode.P))
  45.         {
  46.             isP_Down = true;
  47.         }
  48.  
  49.     }
  50.  
  51.     private async void AsyncLoadTextAsset(string path)
  52.     {
  53.         TextAsset textAsset = await uniTaskSys.AsyncLoad<TextAsset>(path) as TextAsset;
  54.         Debug.Log(textAsset.text);
  55.     }
  56.  
  57.     private void LoadScene(string sceneName)
  58.     {
  59.         uniTaskSys.AsyncLoadScene(sceneName);
  60.     }
  61.  
  62.     public async void AsyncWebRequestTexture(string url)
  63.     {
  64.         var webRequest = UnityWebRequestTexture.GetTexture(url);
  65.         var asyncOperation = await webRequest.SendWebRequest();
  66.         Texture2D texture2D = ((DownloadHandlerTexture)asyncOperation.downloadHandler).texture;
  67.         img_Test.sprite = Sprite.Create(texture2D, new Rect(0, 0, texture2D.width, texture2D.height), new Vector2(0.5f, 0.5f));
  68.         img_Test.SetNativeSize();
  69.     }
  70.  
  71.     /// <summary>
  72.     /// 当两个条件都符合了才执行后面操作
  73.     /// </summary>
  74.     public async void WhenAllTest()
  75.     {
  76.         var firstOperation = UniTask.WaitUntil(() => isO_Down);
  77.         var secondOperation = UniTask.WaitUntil(() => isP_Down);
  78.         await UniTask.WhenAll(firstOperation, secondOperation);
  79.         // 注意，whenAll可以用于平行执行多个资源的读取，非常有用！
  80.         // var (a, b, c) = await UniTask.WhenAll(
  81.         //LoadAsSprite("foo"),
  82.         //LoadAsSprite("bar"),
  83.         //LoadAsSprite("baz"));
  84.         Debug.Log("条件01、02都符合条件了");
  85.     }
  86.  
  87.     /// <summary>
  88.     /// 当其中一个按钮点击了就执行后面操作
  89.     /// </summary>
  90.     private async void WhenAnyTest()
  91.     {
  92.         var firstOperation = UniTask.WaitUntil(() => isO_Down);
  93.         var secondOperation = UniTask.WaitUntil(() => isP_Down);
  94.         await UniTask.WhenAny(firstOperation, secondOperation);
  95.         Debug.Log(isO_Down ? "O被按下" : "P被按下");
  96.     }
  97.  
  98. }
  99.  
  100. public class UniTaskSys
  101. {
  102.     public int count = 0;
  103.  
  104.     public async UniTask<Object> AsyncLoad<T>(string path) where T : Object
  105.     {
  106.         // 加载资源
  107.         var asyncOperation = Resources.LoadAsync<T>(path);
  108.         return (await asyncOperation);
  109.     }
  110.  
  111.     public async void AsyncLoadScene(string sceneName)
  112.     {
  113.         // 加载场景
  114.         await SceneManager.LoadSceneAsync(sceneName).ToUniTask
  115.             (Progress.Create<float>((p) =>
  116.             {
  117.                 Debug.Log($"加载进度为{p * 100:F2}%");
  118.             }));
  119.     }
  120.  
  121.     public async void DelayTest(MonoBehaviour mono = null)
  122.     {
  123.         Debug.Log(Time.realtimeSinceStartup);
  124.         //性能最好，可以设置等待时机，PlayerLoopTiming 对应Unity中playerloop的更新时机
  125.         //await UniTask.Yield(PlayerLoopTiming.LastUpdate);
  126.  
  127.         //等待1秒，类似 yield return new WaitForSeconds(1)，可以设置 ignoreTimeScale
  128.         //await UniTask.Delay(System.TimeSpan.FromSeconds(1), false);
  129.  
  130.         //执行在下一帧的update之后，类似 yield return null，和 UniTask.Yield() 效果一样
  131.         //await UniTask.NextFrame();
  132.  
  133.         //这一帧的最后，类似 yield return new WaitForEndOfFrame()，this是一个MonoBehaviour
  134.         //await UniTask.WaitForEndOfFrame(mono);
  135.  
  136.         //类似 yield return new WaitForFixedUpdate，和 await UniTask.Yield(PlayerLoopTiming.FixedUpdate)效果一样
  137.         //await UniTask.WaitForFixedUpdate();
  138.  
  139.         //延迟5帧
  140.         //await UniTask.DelayFrame(5);
  141.  
  142.         //类似 yield return new WaitUntil(() => count > 10)，当count > 10时才执行后面逻辑
  143.         await UniTask.WaitUntil(() => count > 10);
  144.  
  145.         Debug.Log(Time.realtimeSinceStartup);
  146.     }
  147.  
  148.  
  149.  
  150. }
  1. using Cysharp.Threading.Tasks;
  2. using System;
  3. using System.Collections;
  4. using System.Collections.Generic;
  5. using System.Threading;
  6. using UnityEngine;
  7. using UnityEngine.UI;
  8.  
  9. public class UniTaskCancel : MonoBehaviour
  10. {
  11.     public Transform FirstTransform;
  12.     public Transform SecondTransform;
  13.  
  14.     public Button FirstRunButton;
  15.     public Button SecondRunButton;
  16.  
  17.     public Button FirstCancelButton;
  18.     public Button SecondCancelButton;
  19.  
  20.     //做取消时需要创建这个对象
  21.     private CancellationTokenSource _firstCancelToken;
  22.     private CancellationTokenSource _secondCancelToken;
  23.     private CancellationTokenSource _linkedCancelToken;
  24.  
  25.     private void Start()
  26.     {
  27.         FirstRunButton.onClick.AddListener(OnClickFirstMove);
  28.         SecondRunButton.onClick.AddListener(OnClickSecondMove);
  29.  
  30.         FirstCancelButton.onClick.AddListener(OnClickFirstCancel);
  31.         SecondCancelButton.onClick.AddListener(OnClickSecondCancel);
  32.  
  33.         _firstCancelToken = new CancellationTokenSource();
  34.         // 注意这里可以直接先行设置多久以后取消
  35.         // _firstCancelToken = new CancellationTokenSource(TimeSpan.FromSeconds(1.5f));
  36.         _secondCancelToken = new CancellationTokenSource();
  37.         //用两个token创建新的linkedCancelToken，当其中一个取消后，linkedCancelToken也会取消，
  38.         _linkedCancelToken =
  39.             CancellationTokenSource.CreateLinkedTokenSource(_firstCancelToken.Token, _secondCancelToken.Token);
  40.     }
  41.  
  42.     /// <summary>
  43.     /// 移动first，使用try catch监听取消信号
  44.     /// </summary>
  45.     private async void OnClickFirstMove()
  46.     {
  47.         try
  48.         {
  49.             await MoveTransform(FirstTransform, _firstCancelToken.Token);
  50.         }
  51.         catch (OperationCanceledException e)
  52.         {
  53.             //发出取消信号，这里会抛异常
  54.             Debug.Log("first已经被取消");
  55.         }
  56.     }
  57.  
  58.     /// <summary>
  59.     /// 移动second，忽略异常的抛出，返回一个值元组，这种方式性能更好
  60.     /// </summary>
  61.     private async void OnClickSecondMove()
  62.     {
  63.         //第一个参数表示是否取消，第二个参数时await的返回值
  64.         var (cancelled, _) = await MoveTransform(SecondTransform, _secondCancelToken.Token).SuppressCancellationThrow();
  65.         // 使用LinkedToken，当first取消后，second也会取消
  66.         // var (cancelled, _) = await MoveTransform(SecondTransform, _linkedCancelToken.Token).SuppressCancellationThrow();
  67.         if (cancelled)
  68.         {
  69.             Debug.Log("second已经被取消");
  70.         }
  71.     }
  72.  
  73.     private async UniTask<int> MoveTransform(Transform tf, CancellationToken cancellationToken)
  74.     {
  75.         float totalTime = 10;
  76.         float timeElapsed = 0;
  77.         while (timeElapsed <= totalTime)
  78.         {
  79.             timeElapsed += Time.deltaTime;
  80.             await UniTask.NextFrame(cancellationToken);
  81.             tf.transform.localPosition += Vector3.right * Time.deltaTime * 3;
  82.         }
  83.  
  84.         return 0;
  85.     }
  86.  
  87.     /// <summary>
  88.     /// 取消first移动，Token使用后就不能再次使用，得创建新的Token
  89.     /// </summary>
  90.     private void OnClickFirstCancel()
  91.     {
  92.         _firstCancelToken.Cancel();
  93.         _firstCancelToken.Dispose();
  94.         _firstCancelToken = new CancellationTokenSource();
  95.         _linkedCancelToken =
  96.             CancellationTokenSource.CreateLinkedTokenSource(_firstCancelToken.Token, _secondCancelToken.Token);
  97.     }
  98.  
  99.     private void OnClickSecondCancel()
  100.     {
  101.         _secondCancelToken.Cancel();
  102.         _secondCancelToken.Dispose();
  103.         _secondCancelToken = new CancellationTokenSource();
  104.         _linkedCancelToken =
  105.         CancellationTokenSource.CreateLinkedTokenSource(_firstCancelToken.Token, _secondCancelToken.Token);
  106.     }
  107.  
  108.     private void OnDestroy()
  109.     {
  110.         _firstCancelToken.Dispose();
  111.         _secondCancelToken.Dispose();
  112.         _linkedCancelToken.Dispose();
  113.     }
  114. }
  115.  
  1. using System;
  2. using System.Threading;
  3. using Cysharp.Threading.Tasks;
  4. using Cysharp.Threading.Tasks.Linq;
  5. using UnityEngine;
  6. using UnityEngine.UI;
  7.  
  8. /// <summary>
  9. /// UI事件模板
  10. /// </summary>
  11. public class UIEventsSample : MonoBehaviour
  12. {
  13.     public Transform trans_Sphere;
  14.  
  15.     public Button SphereButton;
  16.     public Button DoubleClickButton;
  17.     public Button CoolDownButton;
  18.  
  19.     public float DoubleClickCheckTime = 0.5f;
  20.     public float CooldownTime = 3f;
  21.  
  22.     void Start()
  23.     {
  24.         CheckSphereClick(SphereButton.GetCancellationTokenOnDestroy()).Forget();
  25.         CheckDoubleClickButton(DoubleClickButton, this.GetCancellationTokenOnDestroy()).Forget();
  26.         CheckCooldownClickButton(this.GetCancellationTokenOnDestroy()).Forget();
  27.     }
  28.  
  29.     /// <summary>
  30.     /// 球体连点
  31.     /// </summary>
  32.     private async UniTaskVoid CheckSphereClick(CancellationToken token)
  33.     {
  34.         //将按钮的点击转换为异步可迭代器
  35.         var asyncEnumerable = SphereButton.OnClickAsAsyncEnumerable();
  36.         //ForEachAsync处理每一次点击时的操作，index表示第几次点击，Take(3)表示只处理前三次点击
  37.         await asyncEnumerable.Take(3).ForEachAsync((_, index) =>
  38.         {
  39.             if (token.IsCancellationRequested) return;
  40.             if (index == 0)
  41.             {
  42.                 //第一次点击，放大
  43.                 SphereTweenScale(2, trans_Sphere.localScale.x, 5, token).Forget();
  44.             }
  45.             else if (index == 1)
  46.             {
  47.                 //第二次点击，缩小
  48.                 SphereTweenScale(2, trans_Sphere.localScale.x, 2, token).Forget();
  49.             }
  50.             else if (index == 2)
  51.             {
  52.                 //第三次点击销毁
  53.             }
  54.         }, token);
  55.         GameObject.Destroy(trans_Sphere.gameObject);
  56.         //三次点击后，await完成，可以进行后面的逻辑
  57.         Debug.LogError("done");
  58.     }
  59.  
  60.     private async UniTaskVoid SphereTweenScale(float totalTime, float from, float to, CancellationToken token)
  61.     {
  62.         var trans = trans_Sphere;
  63.         float time = 0;
  64.         while (time < totalTime)
  65.         {
  66.             time += Time.deltaTime;
  67.             if (trans) 
  68.             {
  69.                 trans.localScale = (from + (time / totalTime) * (to - from)) * Vector3.one;
  70.             }
  71.             await UniTask.Yield(PlayerLoopTiming.Update, token);
  72.         }
  73.     }
  74.  
  75.     /// <summary>
  76.     /// 双击按钮
  77.     /// </summary>
  78.     private async UniTaskVoid CheckDoubleClickButton(Button button, CancellationToken token)
  79.     {
  80.         while (true)
  81.         {
  82.             //将点击转换为异步的UniTask，然后等待第一次点击
  83.             var clickAsync = button.OnClickAsync(token);
  84.             await clickAsync;
  85.             Debug.Log($"按钮被第一次点击");
  86.  
  87.             var secondClickAsync = button.OnClickAsync(token);
  88.             //第二次点击和等待时间谁先到，WhenAny返回那个先执行
  89.             int resultIndex = await UniTask.WhenAny(secondClickAsync,
  90.                 UniTask.Delay(TimeSpan.FromSeconds(DoubleClickCheckTime), cancellationToken: token));
  91.             Debug.Log(resultIndex == 0 ? $"按钮被双击了" : $"超时，按钮算单次点击");
  92.  
  93.         }
  94.     }
  95.  
  96.     /// <summary>
  97.     /// 按钮冷却时间
  98.     /// </summary>
  99.     private async UniTaskVoid CheckCooldownClickButton(CancellationToken token)
  100.     {
  101.         var asyncEnumerable = CoolDownButton.OnClickAsAsyncEnumerable();
  102.         await asyncEnumerable.ForEachAwaitAsync(async (_) =>
  103.         {
  104.             Debug.Log("被点击了，冷却中……");
  105.        
  106.             //Delay过程中不会再响应点击操作
  107.             await UniTask.Delay(TimeSpan.FromSeconds(CooldownTime), cancellationToken: token);
  108.             Debug.Log("冷却好了，可以点了……");
  109.         }, cancellationToken: token);
  110.     }
  111.  
  112. }
  1. using Cysharp.Threading.Tasks;
  2. using System;
  3. using System.Threading;
  4. using UnityEngine;
  5. using UnityEngine.Networking;
  6. using UnityEngine.UI;
  7.  
  8. /// <summary>
  9. /// 超时操作
  10. /// </summary>
  11. public class TimeoutTest : MonoBehaviour
  12. {
  13.     public Button TestButton;
  14.  
  15.     private void Start()
  16.     {
  17.         //使用UniTask.UnityAction包装了OnClickTest
  18.         TestButton.onClick.AddListener(UniTask.UnityAction(OnClickTest));
  19.     }
  20.  
  21.     private async UniTaskVoid OnClickTest()
  22.     {
  23.         var res = await GetRequest("https://www.baidu.com/", 2f);
  24.         //var res = await GetRequest("https://www.google.com/", 2f);
  25.         Debug.LogError(res);
  26.     }
  27.  
  28.     private async UniTask<string> GetRequest(string url, float timeout)
  29.     {
  30.         //这个token会在timeout之后发出取消信号
  31.         var cts = new CancellationTokenSource();
  32.         cts.CancelAfterSlim(TimeSpan.FromSeconds(timeout));
  33.  
  34.         var (failed, result) = await UnityWebRequest.Get(url).SendWebRequest().
  35.                 WithCancellation(cts.Token).SuppressCancellationThrow();
  36.         if (!failed)
  37.         {
  38.             //成功了返回网页内容的开头
  39.             return result.downloadHandler.text.Substring(0, 100);
  40.         }
  41.  
  42.         return "超时";
  43.     }
  44. }
  45.  
  1. using Cysharp.Threading.Tasks;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.IO;
  5. using UnityEngine;
  6. using UnityEngine.UI;
  7.  
  8. /// <summary>
  9. /// 切换到主线程
  10. /// </summary>
  11. public class ThreadSample : MonoBehaviour
  12. {
  13.     public Button btn_StandardRun;
  14.     public Button btn_YieldRun;
  15.  
  16.     private void Start()
  17.     {
  18.         btn_StandardRun.onClick.AddListener(UniTask.UnityAction(OnClickStandardRun));
  19.         btn_YieldRun.onClick.AddListener(UniTask.UnityAction(OnClickYieldRun));
  20.     }
  21.  
  22.     public async UniTaskVoid OnClickStandardRun()
  23.     {
  24.         int result = 0;
  25.  
  26.         //切换到其他线程
  27.         await UniTask.RunOnThreadPool(()=> { result = 1; });
  28.         //切换到主线程
  29.         await UniTask.SwitchToMainThread();
  30.  
  31.         Debug.Log($"计算结束,当前结果为：{result}");
  32.     }
  33.  
  34.     /// <summary>
  35.     /// 线程中读取文件
  36.     /// </summary>
  37.     private async UniTaskVoid OnClickYieldRun()
  38.     {
  39.         string fileName = Application.streamingAssetsPath + "/Test.txt";
  40.         await UniTask.SwitchToThreadPool();
  41.         string fileContent = await File.ReadAllTextAsync(fileName);
  42.         //调用 UniTask.Yield 会自动切换会主线程
  43.         await UniTask.Yield(PlayerLoopTiming.Update);
  44.         Debug.LogError(fileContent);
  45.     }
  46.  
  47. }
  1. using Cysharp.Threading.Tasks;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using UnityEngine;
  5. using UnityEngine.UI;
  6.  
  7. public class ForgetSample : MonoBehaviour
  8. {
  9.     public Button StartButton;
  10.     public GameObject Target;
  11.     public const float G = 9.8f;
  12.  
  13.     public float FallTime = 0.5f;
  14.  
  15.     private void Start()
  16.     {
  17.         StartButton.onClick.AddListener(OnClickStart);
  18.     }
  19.  
  20.     /// <summary>
  21.     /// 同步方法中调用异步方法
  22.     /// </summary>
  23.     private void OnClickStart()
  24.     {
  25.         //不需要等待时候就调用Forget
  26.         FallTarget(Target.transform).Forget();
  27.     }
  28.  
  29.     /// <summary>
  30.     /// 使目标掉落，async UniTaskVoid是async UniTask的轻量级版本
  31.     /// </summary>
  32.     private async UniTaskVoid FallTarget(Transform targetTrans)
  33.     {
  34.         Vector3 startPosition = targetTrans.position;
  35.         float fallTime = 1f;
  36.         float elapsedTime = 0;
  37.         while (elapsedTime <= fallTime)
  38.         {
  39.             elapsedTime += Time.deltaTime;
  40.             float fallY = 0.5f * G * elapsedTime * elapsedTime;
  41.             targetTrans.position = startPosition + Vector3.down * fallY;
  42.             //GetCancellationTokenOnDestroy 表示获取一个依赖对象生命周期的Cancel句柄，
  43.             //当对象被销毁时，将会调用这个Cancel句柄，从而实现取消的功能
  44.             await UniTask.Yield(this.GetCancellationTokenOnDestroy());
  45.         }
  46.     }
  47.  
  48.  
  49. }
  50.  
  1. using Cysharp.Threading.Tasks;
  2. using System;
  3. using System.Collections;
  4. using System.Collections.Generic;
  5. using UnityEngine;
  6. using UnityEngine.UI;
  7.  
  8. public class CallbackSample : MonoBehaviour
  9. {
  10.     public Button CallbackButton;
  11.     public GameObject Target;
  12.     public const float G = 9.8f;
  13.  
  14.     public event EventHandler OneSecondHandler;
  15.  
  16.     private void Start()
  17.     {
  18.         CallbackButton.onClick.AddListener(UniTask.UnityAction(OnClickCallback));
  19.         OneSecondHandler += CallbackSample_OneSecondHandler;
  20.     }
  21.  
  22.     private void CallbackSample_OneSecondHandler(object sender, EventArgs e)
  23.     {
  24.         Debug.Log("1S 事件被触发");
  25.     }
  26.  
  27.     private async UniTaskVoid OnClickCallback()
  28.     {
  29.         float time = Time.time;
  30.         UniTaskCompletionSource source = new UniTaskCompletionSource();
  31.         FallTarget(Target.transform, source).Forget();
  32.         await source.Task;// UniTaskCompletionSource产生的UnitTask是可以复用的
  33.         Debug.Log($"耗时 {Time.time - time}秒");
  34.     }
  35.  
  36.     /// <summary>
  37.     /// UniTask运行中执行回调
  38.     /// UniTaskCompletionSource是对UniTask和CancellationToken的封装
  39.     /// </summary>
  40.     private async UniTask FallTarget(Transform targetTrans, UniTaskCompletionSource source)
  41.     {
  42.         Vector3 startPosition = targetTrans.position;
  43.         float fallTime = 2f;
  44.         float elapsedTime = 0;
  45.         while (elapsedTime <= fallTime)
  46.         {
  47.             elapsedTime += Time.deltaTime;
  48.             //当下落时间超过1秒时设置操作
  49.             if (elapsedTime > 1f)
  50.             {
  51.                 OneSecondHandler?.Invoke(this,EventArgs.Empty);
  52.                 // 表示操作完成
  53.                 source.TrySetResult();
  54.                 // 失败
  55.                 // source.TrySetException(new SystemException());
  56.                 // 取消
  57.                 // source.TrySetCanceled(someToken);
  58.  
  59.                 // 泛型类UniTaskCompletionSource<T> SetResult是T类型，返回UniTask<T>
  60.             }
  61.  
  62.             float fallY = 0.5f * G * elapsedTime * elapsedTime;
  63.             targetTrans.position = startPosition + Vector3.down * fallY;
  64.             await UniTask.Yield(this.GetCancellationTokenOnDestroy());
  65.         }
  66.     }
  67.  
  68.     private void OnDestroy()
  69.     {
  70.         OneSecondHandler -= CallbackSample_OneSecondHandler;
  71.     }
  72. }
  73.  
  1. using Cysharp.Threading.Tasks;
  2. using Cysharp.Threading.Tasks.Linq;
  3. using System.Collections;
  4. using System.Collections.Generic;
  5. using System.Threading;
  6. using UnityEngine;
  7. using UnityEngine.UI;
  8.  
  9. public class AsyncReactivePropertySample : MonoBehaviour
  10. {
  11.     public int maxHp = 100;
  12.     public float totalChangeTime = 1f;
  13.     public Text ShowHpText;
  14.     public Text StateText;
  15.     public Text ChangeText;
  16.  
  17.     public Slider HpSlider;
  18.     public Image HpBarImage;
  19.  
  20.     public Button HealButton;
  21.     public Button HurtButton;
  22.  
  23.     private AsyncReactiveProperty<string> currentHpStr;
  24.     private AsyncReactiveProperty<int> currentHp;
  25.     private int maxHeal = 10;
  26.     private int maxHurt = 10;
  27.     private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
  28.     private CancellationTokenSource _linkedTokenSource;
  29.  
  30.     private void Start()
  31.     {
  32.         // 设置AsyncReactiveProperty
  33.         currentHpStr = new AsyncReactiveProperty<string>($"当前血量：{maxHp}/{maxHp}");
  34.         currentHp = new AsyncReactiveProperty<int>(maxHp);
  35.         HpSlider.maxValue = maxHp;
  36.         HpSlider.value = maxHp;
  37.  
  38.         currentHp.Subscribe(OnHpChange);
  39.         CheckHpChange(currentHp).Forget();
  40.         CheckFirstLowHp(currentHp).Forget();
  41.  
  42.         currentHpStr.BindTo(ShowHpText);
  43.  
  44.         HealButton.onClick.AddListener(OnClickHeal);
  45.         HurtButton.onClick.AddListener(OnClickHurt);
  46.  
  47.         _linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_cancellationTokenSource.Token,
  48.                 this.GetCancellationTokenOnDestroy());
  49.  
  50.     }
  51.  
  52.     private void OnClickHeal()
  53.     {
  54.         ChangeHp(Random.Range(0, maxHeal));
  55.     }
  56.  
  57.     private void OnClickHurt()
  58.     {
  59.         ChangeHp(-Random.Range(0, maxHurt));
  60.     }
  61.  
  62.     private void ChangeHp(int deltaHp)
  63.     {
  64.         currentHp.Value = Mathf.Clamp(currentHp.Value + deltaHp, 0, maxHp);
  65.         currentHpStr.Value = $"当前血量：{currentHp.Value}/{maxHp}";
  66.     }
  67.  
  68.     /// <summary>
  69.     /// currentHp变化时修改提示信息
  70.     /// </summary>
  71.     private async UniTaskVoid CheckHpChange(AsyncReactiveProperty<int> hp)
  72.     {
  73.         int hpValue = hp.Value;
  74.         // WithoutCurrent 忽略初始值
  75.         await hp.WithoutCurrent().ForEachAsync((_, index) =>
  76.         {
  77.             ChangeText.text = $"血量发生变化 第{index}次 变化{hp.Value - hpValue}";
  78.             hpValue = hp.Value;
  79.         }, this.GetCancellationTokenOnDestroy());
  80.     }
  81.  
  82.     /// <summary>
  83.     /// currentHp低于临界值，显示提示信息
  84.     /// </summary>
  85.     private async UniTaskVoid CheckFirstLowHp(AsyncReactiveProperty<int> hp)
  86.     {
  87.         await hp.FirstAsync((value) => value < maxHp * 0.4f, this.GetCancellationTokenOnDestroy());
  88.         StateText.text = "首次血量低于界限，请注意!";
  89.     }
  90.  
  91.     private async UniTaskVoid OnHpChange(int hp)
  92.     {
  93.         _cancellationTokenSource.Cancel();
  94.         _cancellationTokenSource = new CancellationTokenSource();
  95.         _linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_cancellationTokenSource.Token,
  96.                 this.GetCancellationTokenOnDestroy());
  97.         await SyncSlider(hp, _linkedTokenSource.Token);
  98.     }
  99.  
  100.     /// <summary>
  101.     /// 同步血条
  102.     /// </summary>
  103.     private async UniTask SyncSlider(int hp, CancellationToken token)
  104.     {
  105.         var sliderValue = HpSlider.value;
  106.         float needTime = Mathf.Abs((sliderValue - hp) / maxHp * totalChangeTime);
  107.         float useTime = 0;
  108.         while (useTime < needTime)
  109.         {
  110.             useTime += Time.deltaTime;
  111.             bool result = await UniTask.Yield(PlayerLoopTiming.Update, token)
  112.                 .SuppressCancellationThrow();
  113.             if (result)
  114.             {
  115.                 return;
  116.             }
  117.  
  118.             var newValue = (sliderValue + (hp - sliderValue) * (useTime / needTime));
  119.             SetNewValue(newValue);
  120.         }
  121.     }
  122.  
  123.     private void SetNewValue(float newValue)
  124.     {
  125.         if (!HpSlider) return;
  126.         HpSlider.value = newValue;
  127.         HpBarImage.color = HpSlider.value / maxHp < 0.4f ? Color.red : Color.white;
  128.     }
  129. }
  130.

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

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

  

闽ICP备14008679号