Unity 代码重复问题及解决方案笔记

于 2024-11-20 10:51:51 发布
阅读量681 收藏 11
点赞数 19
文章标签： unity 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bugmaker2000/article/details/143905113
版权

Unity 代码重复问题及解决方案笔记

1. 引言

在 Unity 游戏开发中，经常会遇到多个对象的代码逻辑相似或重复的情况。例如，玩家的移动、敌人的移动和子弹的移动代码往往非常相似。为了提高代码的可维护性和复用性，可以采用以下几种方法来解决这些问题。

2. 方法一：抽象基类

优点：

  • 代码复用：通过将公共逻辑提取到基类中，可以在多个子类中复用这些逻辑。
  • 继承层次：可以建立清晰的继承层次，方便管理和扩展。
  • 多态性：可以利用多态性，通过基类引用调用子类的具体实现。

缺点：

  • 耦合度高：基类和子类之间耦合度较高，修改基类可能会影响所有子类。
  • 灵活性较低：一旦基类的设计发生变化，所有继承该基类的子类都需要相应调整。
  • 单一继承限制：C# 不支持多重继承，只能继承一个基类。

适用场景：

  • 当多个类有大量共同的逻辑和属性时。
  • 当需要通过继承层次来管理类的复杂度时。

示例代码：

// 抽象基类
public abstract class MovableObject : MonoBehaviour
{
    public float speed = 5.0f;
    protected Rigidbody2D rb;

    protected virtual void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    protected virtual void Move(Vector2 direction)
    {
        Vector2 movement = direction * speed * Time.deltaTime;
        rb.MovePosition(rb.position + movement);
    }
}

// 玩家控制器
public class PlayerController : MovableObject
{
    private Animator animator;

    protected override void Start()
    {
        base.Start();
        animator = GetComponent<Animator>();
    }

    void Update()
    {
        HandleMovement();
    }

    void HandleMovement()
    {
        float moveX = Input.GetAxis("Horizontal");
        float moveY = Input.GetAxis("Vertical");

        Vector2 direction = new Vector2(moveX, moveY);
        Move(direction);

        animator.SetFloat("SpeedX", moveX);
        animator.SetFloat("SpeedY", moveY);
    }
}

// 敌人控制器
public class EnemyController : MovableObject
{
    private Transform target;

    protected override void Start()
    {
        base.Start();
        target = GameObject.FindWithTag("Player").transform;
    }

    void Update()
    {
        HandleMovement();
    }

    void HandleMovement()
    {
        Vector2 direction = (Vector2)(target.position - transform.position).normalized;
        Move(direction);
    }
}
3. 方法二：接口

优点：

  • 解耦：接口定义了行为契约，不涉及具体实现，降低了类之间的耦合度。
  • 多态性：可以通过接口引用调用不同类的实现，增强代码的灵活性。
  • 多重继承：一个类可以实现多个接口，实现类似多重继承的效果。

缺点：

  • 无默认实现：接口不能提供默认实现，所有实现类必须自己实现接口方法。
  • 变更困难：接口一旦发布，修改接口会破坏现有实现，需要谨慎设计。

适用场景：

  • 当多个类需要实现相同的行为，但具体实现可能不同。
  • 当需要定义一组行为契约，允许多个类实现这些行为。

示例代码：

// 移动接口
public interface IMovable
{
    void Move(Vector2 direction);
}

// 玩家控制器
public class PlayerController : MonoBehaviour, IMovable
{
    public float speed = 5.0f;
    private Rigidbody2D rb;
    private Animator animator;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        animator = GetComponent<Animator>();
    }

    void Update()
    {
        HandleMovement();
    }

    void HandleMovement()
    {
        float moveX = Input.GetAxis("Horizontal");
        float moveY = Input.GetAxis("Vertical");

        Vector2 direction = new Vector2(moveX, moveY);
        Move(direction);

        animator.SetFloat("SpeedX", moveX);
        animator.SetFloat("SpeedY", moveY);
    }

    public void Move(Vector2 direction)
    {
        Vector2 movement = direction * speed * Time.deltaTime;
        rb.MovePosition(rb.position + movement);
    }
}

// 敌人控制器
public class EnemyController : MonoBehaviour, IMovable
{
    public float speed = 5.0f;
    private Rigidbody2D rb;
    private Transform target;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        target = GameObject.FindWithTag("Player").transform;
    }

    void Update()
    {
        HandleMovement();
    }

    void HandleMovement()
    {
        Vector2 direction = (Vector2)(target.position - transform.position).normalized;
        Move(direction);
    }

    public void Move(Vector2 direction)
    {
        Vector2 movement = direction * speed * Time.deltaTime;
        rb.MovePosition(rb.position + movement);
    }
}
4. 方法三：组件化

优点：

  • 高度解耦：每个组件负责一个特定的功能，类之间的耦合度低。
  • 灵活组合：可以通过组合不同的组件来构建复杂的行为。
  • 重用性高：组件可以在多个对象之间复用。

缺点：

  • 复杂性增加：组件越多，管理起来越复杂，需要更多的协调和通信机制。
  • 性能开销：组件之间的通信可能带来额外的性能开销。

适用场景：

  • 当对象需要多种不同的行为，且这些行为可以独立开发和管理。
  • 当需要高度灵活和可扩展的架构时。

示例代码：

// 移动组件
public class MovementComponent : MonoBehaviour
{
    public float speed = 5.0f;
    private Rigidbody2D rb;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    public void Move(Vector2 direction)
    {
        Vector2 movement = direction * speed * Time.deltaTime;
        rb.MovePosition(rb.position + movement);
    }
}

// 玩家控制器
public class PlayerController : MonoBehaviour
{
    private MovementComponent movementComponent;
    private Animator animator;

    void Start()
    {
        movementComponent = GetComponent<MovementComponent>();
        animator = GetComponent<Animator>();
    }

    void Update()
    {
        HandleMovement();
    }

    void HandleMovement()
    {
        float moveX = Input.GetAxis("Horizontal");
        float moveY = Input.GetAxis("Vertical");

        Vector2 direction = new Vector2(moveX, moveY);
        movementComponent.Move(direction);

        animator.SetFloat("SpeedX", moveX);
        animator.SetFloat("SpeedY", moveY);
    }
}

// 敌人控制器
public class EnemyController : MonoBehaviour
{
    private MovementComponent movementComponent;
    private Transform target;

    void Start()
    {
        movementComponent = GetComponent<MovementComponent>();
        target = GameObject.FindWithTag("Player").transform;
    }

    void Update()
    {
        HandleMovement();
    }

    void HandleMovement()
    {
        Vector2 direction = (Vector2)(target.position - transform.position).normalized;
        movementComponent.Move(direction);
    }
}
5. 方法四：工厂模式

优点：

  • 封装创建逻辑：将对象的创建逻辑封装在工厂类中，隐藏了创建细节。
  • 易于扩展：新增对象类型时，只需修改工厂类，无需改动客户端代码。
  • 单一职责：工厂类专注于对象的创建，符合单一职责原则。

缺点：

  • 增加复杂度：引入了工厂类，增加了系统的复杂度。
  • 依赖性：客户端依赖于工厂类，如果工厂类设计不合理，可能影响整个系统的稳定性。

适用场景：

  • 当对象的创建过程复杂，需要封装在单独的类中。
  • 当需要动态创建不同类型的对象，且这些对象有共同的接口或基类。

示例代码：

// 移动物体工厂
public class MovableObjectFactory
{
    public static MovableObject CreateMovableObject(MovableObjectType type, Transform parent)
    {
        GameObject obj = new GameObject(type.ToString());
        obj.transform.SetParent(parent);

        switch (type)
        {
            case MovableObjectType.Player:
                obj.AddComponent<PlayerController>();
                break;
            case MovableObjectType.Enemy:
                obj.AddComponent<EnemyController>();
                break;
            case MovableObjectType.Bullet:
                obj.AddComponent<BulletController>();
                break;
            default:
                throw new ArgumentException("Unknown movable object type");
        }

        return obj.GetComponent<MovableObject>();
    }
}

public enum MovableObjectType
{
    Player,
    Enemy,
    Bullet
}
6. 总结

选择哪种方法取决于您的具体需求和项目的复杂度。以下是一些建议：

  • 抽象基类：适用于多个类有大量共同的逻辑和属性，且需要通过继承层次来管理类的复杂度。
  • 接口：适用于多个类需要实现相同的行为，但具体实现可能不同，需要定义一组行为契约。
  • 组件化：适用于对象需要多种不同的行为，且这些行为可以独立开发和管理，需要高度灵活和可扩展的架构。
  • 工厂模式：适用于对象的创建过程复杂，需要封装在单独的类中，或者需要动态创建不同类型的对象。
BugMaker2000
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值