Roguelite-Game-Developing-Team/Gen_Hack-and-Slash-Roguelite
2
0
Fork 2
Code Issues Pull Requests Actions Packages Projects Releases Activity

(client)feat:实现动画组件和图片组件预制体

Browse Source
This commit is contained in:
m0_75251201
2025-07-24 13:19:27 +08:00
parent 179123f660
commit 8471f00b64
13 changed files with 605 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
Client/Assets/Scripts/Entity/Entity.cs
View File

@ -3,6 +3,7 @@ using System.Collections.Generic;
using AI;
using Base;
using Data;
using Prefab;
using UnityEngine;
using UnityEngine.Serialization;
@ -10,6 +11,9 @@ namespace Entity
{
public class Entity:MonoBehaviour,ITick
{
public SpriteAnimator animatorPrefab;
public ImagePrefab imagePrefab;
public AIBase aiTree;
public JobBase currentJob;
public AttributesDef attributes;
@ -38,6 +42,8 @@ namespace Entity
private bool _isPlayerControlled = false;
private bool _warning = false;
private Dictionary<Orientation,List<ITick>> bodyNode=new();
private Orientation currentOrientation=Orientation.Down;
public virtual void Init(PawnDef pawnDef)
{
@ -54,6 +60,8 @@ namespace Entity
foreach (var orientation in orientations)
{
currentOrientation=orientation;
bodyNode[orientation]=new();
// 获取当前方向的绘图节点
var drawNode = drawingOrder.GetDrawingOrder(orientation);
@ -63,32 +71,26 @@ namespace Entity
InitBodyPart(drawNode, directionRoot);
}
currentOrientation=Orientation.Down;
}
// 递归初始化单个绘图节点及其子节点
public virtual void InitBodyPart(DrawNodeDef drawNode, GameObject parent)
{
if(drawNode==null) return;
// 创建新的 GameObject 表示当前节点
var nodeObject = new GameObject(drawNode.nodeName);
// 设置节点的父对象
nodeObject.transform.SetParent(parent.transform, false);
// 设置节点的位置
nodeObject.transform.localPosition = new Vector3(drawNode.position.x, drawNode.position.y, 0);
// 根据节点类型设置其他特性（例如动画或图片）
GameObject nodeObject;
switch (drawNode.drawNodeType)
{
case DrawNodeType.Image:
var spriteRenderer = nodeObject.AddComponent<SpriteRenderer>();
spriteRenderer.color = Color.white; // 默认颜色
nodeObject = Instantiate(imagePrefab.gameObject);
break;
case DrawNodeType.Animation:
var animator = nodeObject.AddComponent<Animator>();
animator.runtimeAnimatorController = null; // 需要手动设置动画控制器
nodeObject = Instantiate(animatorPrefab.gameObject);
ITick tick = nodeObject.GetComponent<SpriteAnimator>();
if (tick != null)
bodyNode[currentOrientation].Add(tick);
break;
default:
throw new ArgumentOutOfRangeException();
@ -110,6 +112,14 @@ namespace Entity
{
AutoBehave();
}
foreach (var bodyPart in bodyNode.Values)
{
foreach (var tick in bodyPart)
{
tick.Tick();
}
}
}
public virtual void TryAttck()

151
Client/Assets/Scripts/Entity/SpriteAnimator.cs
View File

@ -1,151 +0,0 @@
using UnityEngine;
namespace Entity
{
public class SpriteAnimator : MonoBehaviour
{
// 引用 SpriteRenderer 组件
[SerializeField] private SpriteRenderer spriteRenderer;
// 精灵列表
[SerializeField] private Sprite[] sprites;
// 动画帧率 (Frames Per Second)
[SerializeField] private float fps = 10f;
// 是否暂停动画
[SerializeField] private bool isPaused = false;
// 暂停时显示的静态精灵索引 (-1 表示不显示静态精灵)
[SerializeField] private int staticSpriteIndex = -1;
// 当前帧索引
private int currentFrameIndex = 0;
// 帧间隔时间
private float frameInterval;
// 计时器
private float timer;
private void Start()
{
// 初始化帧间隔时间
frameInterval = 1f / fps;
// 如果指定了静态精灵索引，则直接显示静态精灵
if (staticSpriteIndex >= 0 && staticSpriteIndex < sprites.Length)
{
ShowStaticSprite(staticSpriteIndex);
}
else
{
// 否则从第一个精灵开始
UpdateSprite();
}
}
private void Update()
{
// 如果暂停并且没有设置静态精灵，则不更新
if (isPaused && staticSpriteIndex == -1) return;
// 如果暂停并设置了静态精灵，则直接显示静态精灵
if (isPaused && staticSpriteIndex >= 0)
{
ShowStaticSprite(staticSpriteIndex);
return;
}
// 更新计时器
timer += Time.deltaTime;
// 如果达到下一帧的时间间隔
if (timer >= frameInterval)
{
timer -= frameInterval; // 重置计时器
UpdateSprite(); // 更新精灵
}
}
/// <summary>
/// 更新当前显示的精灵
/// </summary>
private void UpdateSprite()
{
if (sprites.Length == 0) return; // 如果没有精灵，则退出
// 设置当前帧的精灵
spriteRenderer.sprite = sprites[currentFrameIndex];
// 循环播放：更新到下一帧
currentFrameIndex = (currentFrameIndex + 1) % sprites.Length;
}
/// <summary>
/// 显示静态精灵
/// </summary>
/// <param name="index">静态精灵的索引</param>
private void ShowStaticSprite(int index)
{
if (index < 0 || index >= sprites.Length)
{
Debug.LogWarning("静态精灵索引超出范围！");
return;
}
// 显示指定的静态精灵
spriteRenderer.sprite = sprites[index];
}
/// <summary>
/// 开始播放动画
/// </summary>
public void PlayAnimation()
{
isPaused = false; // 取消暂停
staticSpriteIndex = -1; // 清除静态精灵索引
}
/// <summary>
/// 暂停动画并显示静态精灵
/// </summary>
/// <param name="index">静态精灵的索引</param>
public void PauseAnimationWithStaticSprite(int index)
{
if (index < 0 || index >= sprites.Length)
{
Debug.LogWarning("静态精灵索引超出范围！");
return;
}
isPaused = true; // 暂停动画
staticSpriteIndex = index; // 设置静态精灵索引
}
/// <summary>
/// 暂停动画但不显示静态精灵
/// </summary>
public void PauseAnimation()
{
isPaused = true; // 暂停动画
staticSpriteIndex = -1; // 不显示静态精灵
}
/// <summary>
/// 设置帧率
/// </summary>
/// <param name="newFps">新的帧率</param>
public void SetFPS(float newFps)
{
if (newFps <= 0)
{
Debug.LogWarning("帧率必须大于 0！");
return;
}
fps = newFps;
frameInterval = 1f / fps; // 更新帧间隔时间
}
}
}

2
Client/Assets/Scripts/Managers/PackagesImageManager.cs
View File

@ -11,7 +11,7 @@ namespace Managers
public Dictionary<string, Dictionary<string, Texture2D>> packagesImages = new();
public Dictionary<string, Dictionary<string, Sprite>> sprites = new();
public void Init()
{
if (packagesImages.Count > 0)

144
Client/Assets/Scripts/Prefab/ImagePrefab.cs Normal file
View File

@ -0,0 +1,144 @@
using Base;
using UnityEngine;
namespace Prefab
{
[RequireComponent(typeof(SpriteRenderer))]
public class ImagePrefab : MonoBehaviour
{
[Header("Display Settings")] [SerializeField]
private Sprite _defaultSprite;
[SerializeField] private Color _tintColor = Color.white;
[SerializeField, Range(0, 1)] private float _alpha = 1f;
[SerializeField] private bool _preserveAspect = true;
private SpriteRenderer _renderer;
private Vector2 _originalSize;
private bool _isInitialized;
public Sprite DisplayedSprite => _renderer.sprite;
public Color CurrentColor => _renderer.color;
private void Awake()
{
InitializeRenderer();
}
private void InitializeRenderer()
{
if (_isInitialized) return;
_renderer = GetComponent<SpriteRenderer>();
// 初始尺寸记录
if (_defaultSprite != null)
{
_originalSize = new Vector2(
_defaultSprite.rect.width / _defaultSprite.pixelsPerUnit,
_defaultSprite.rect.height / _defaultSprite.pixelsPerUnit
);
}
// 设置初始状态
ApplyVisualSettings();
_isInitialized = true;
}
private void ApplyVisualSettings()
{
if (!_isInitialized) InitializeRenderer();
// 设置精灵和颜色
_renderer.sprite = _defaultSprite;
_renderer.color = new Color(_tintColor.r, _tintColor.g, _tintColor.b, _alpha);
// 保持原始纵横比
if (_preserveAspect && _defaultSprite != null)
{
MaintainAspectRatio();
}
}
private void MaintainAspectRatio()
{
Vector2 currentSize = transform.lossyScale;
float aspectRatio = _originalSize.x / _originalSize.y;
if (currentSize.x == 0 || currentSize.y == 0) return;
float currentAspect = currentSize.x / currentSize.y;
if (Mathf.Abs(currentAspect - aspectRatio) > 0.01f)
{
Vector2 newScale = currentSize;
if (currentAspect > aspectRatio)
{
newScale.x = currentSize.y * aspectRatio;
}
else
{
newScale.y = currentSize.x / aspectRatio;
}
transform.localScale = newScale;
}
}
// 公共控制方法
public void SetSprite(Sprite newSprite)
{
_defaultSprite = newSprite;
if (_defaultSprite != null)
{
_originalSize = new Vector2(
_defaultSprite.rect.width / _defaultSprite.pixelsPerUnit,
_defaultSprite.rect.height / _defaultSprite.pixelsPerUnit
);
}
ApplyVisualSettings();
}
public void SetColor(Color newColor)
{
_tintColor = newColor;
ApplyVisualSettings();
}
public void SetAlpha(float newAlpha)
{
_alpha = Mathf.Clamp01(newAlpha);
ApplyVisualSettings();
}
public void ToggleVisibility(bool isVisible)
{
if (!_isInitialized) InitializeRenderer();
_renderer.enabled = isVisible;
}
public void SetSortingLayer(string layerName, int order)
{
if (!_isInitialized) InitializeRenderer();
_renderer.sortingLayerName = layerName;
_renderer.sortingOrder = order;
}
#if UNITY_EDITOR
private void OnValidate()
{
// 编辑器模式下实时预览变化
if (UnityEditor.EditorApplication.isPlaying)
{
ApplyVisualSettings();
}
else if (GetComponent<SpriteRenderer>() != null)
{
GetComponent<SpriteRenderer>().sprite = _defaultSprite;
GetComponent<SpriteRenderer>().color = new Color(_tintColor.r, _tintColor.g, _tintColor.b, _alpha);
}
}
#endif
}
}

3
Client/Assets/Scripts/Prefab/ImagePrefab.cs.meta Normal file
View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 0c360a9f1baf4eaf9afa85617c395b0d
timeCreated: 1753331527

90
Client/Assets/Scripts/Prefab/SpriteAnimator.cs Normal file
View File

@ -0,0 +1,90 @@
using Base;
using UnityEngine;
namespace Prefab
{
[RequireComponent(typeof(SpriteRenderer))]
public class SpriteAnimator : MonoBehaviour, ITick
{
// 公开字段（可在编辑器中设置）
[SerializeField] private Sprite[] _sprites; // 动画精灵序列
[SerializeField] private float _fps = 2; // 每秒帧数
[SerializeField] private Sprite _staticSprite; // 暂停时的静态精灵
private SpriteRenderer _renderer; // 渲染器组件
private bool _isPaused; // 暂停状态
private float _frameTimer; // 帧计时器
private int _currentFrameIndex; // 当前帧索引
private void Awake()
{
_renderer = GetComponent<SpriteRenderer>();
ValidateStartFrame();
}
// ITick接口实现
public void Tick()
{
var deltaTime=Time.deltaTime;
if (_isPaused)
{
HandlePausedState();
return;
}
PlayAnimation(deltaTime);
}
private void ValidateStartFrame()
{
// 确保有精灵时可显示有效帧
if (_sprites != null && _sprites.Length > 0)
{
_currentFrameIndex = Mathf.Clamp(_currentFrameIndex, 0, _sprites.Length - 1);
_renderer.sprite = _sprites[_currentFrameIndex];
}
else
{
_renderer.sprite = null;
}
}
private void HandlePausedState()
{
// 优先使用静态精灵，否则保持当前帧
if (_staticSprite)
{
_renderer.sprite = _staticSprite;
}
}
private void PlayAnimation(float deltaTime)
{
if (_sprites == null || _sprites.Length == 0) return;
// 更新帧计时器
_frameTimer += deltaTime;
float frameDuration = 1f / _fps;
// 检查帧切换条件
while (_frameTimer >= frameDuration)
{
_frameTimer -= frameDuration;
NextFrame();
}
}
private void NextFrame()
{
// 循环播放动画
_currentFrameIndex = (_currentFrameIndex + 1) % _sprites.Length;
_renderer.sprite = _sprites[_currentFrameIndex];
}
// 外部控制方法
public void SetPaused(bool paused) => _isPaused = paused;
public void SetSprites(Sprite[] newSprites) => _sprites = newSprites;
public void SetFPS(float newFPS) => _fps = Mathf.Max(0.1f, newFPS);
public void SetStaticSprite(Sprite sprite) => _staticSprite = sprite;
}
}

0
Client/Assets/Scripts/Entity/SpriteAnimator.cs.meta → Client/Assets/Scripts/Prefab/SpriteAnimator.cs.meta
View File