BufferSystem

Buff可以理解成是一种技能,这种技能加持在一个游戏对象身上,增加这种Buff所特有的属性,包括持续时间,次数等,常用语游戏里面的技能加减血,加减速度等
1.所有Buffer的类型基类
========================================
using UnityEngine;
using System.Collections;
using System;

//所有Buffer的类型基类,抽象类可以包含抽象方法和普通方法,
//但是必须要在子类里实现所有基类里面的抽象方法
public abstract class BufferStateBase
{
    // 1.当前状态控制的游戏对象是谁
    public Transform CurrCtrl {
        get;
        set;
    }

    // 2.当前Buffer的类型 -> Buffer? Debuffer? PerBuffer? PerDeBuffer?
    public object CurrBufferType {
        get;
        set;
    }

    // 3.当前Buffer具体值 -> SpeedUp? Disarm?
    public object CurrBurrferState {
        get;
        set;
    }

    // 4.当前buffer的具体描述, 注意一个抽象方法,在继承它的子类里必须实现他一
    public abstract string CurrBufferInfo {
        get;
    }

    // 5.当前Buffer所接受的具体参数,注意是BufferArgs(里面的参数有一个脚本来定义)类型的
    public BufferArgs CurrArgs {
        set;
        get;
    }

    //一系列回调
    public abstract bool OnEnter ();

    public abstract bool OnUpdate ();

    public abstract bool OnExit ();
}
2.当前Buffer所具有的具体参数
using UnityEngine;
using System.Collections;

public class BufferArgs
{
    // 是否允许重复添加?
    // false: 不允许重复添加, 但是更新持续时间,意思是当添加一个Buffer时,
    //如果已经添加了相同的Buffer,那么就只会重新刷新持续时间,而不会重复添加
    // true: 允许重复添加, 两个相同的buffer同时发挥作用
    public bool m_addition = false;

    // 如果是周期性的buffer, 每一次间隔是多少?
    public float m_Timer;
    // 如果是按次数计量
    public int m_Times;
    // 能否被驱散
    public bool m_Dispel;
    // 持续时间
    public float m_ContinuousTime;
    // 是否结束
    public bool isOver = false;

    //其他一些可能用到的参数
    public float m_fValue1;
    public float m_fValue2;
    public float m_fValue3;
    public float m_fValue4;

    public string m_sValue1;
    public string m_sValue2;
    public string m_sValue3;
    public string m_sValue4;

    public bool m_bValue1;
    public bool m_bValue2;
    public bool m_bValue3;
    public bool m_bValue4;
}
3. 这个类中存放各种枚举的类型
public class BufferType
{
    // 正面buffer
    public enum Buffer
    {
        AllType,
        //加速的Buffer
        BufferSpeedUp,
        //无敌Buffer
        BufferInvincible,
    }

    // 负面buffer
    public enum DeBuffer
    {
        AllType,
        //减速的Buffer
        BufferSlowDown,
        //除装的Buffer
        BufferDisarm,
    }

    // 周期性的正面buffer
    public enum PerBuffer
    {
        AllType,
        //持续加血的Buffer
        BufferAddBlood,
        //持续加魔法值的Buffer
        BufferAddMagic,
    }

    // 周期性的负面buffer
    public enum PerDeBuffer
    {
        AllType,
        //持续减血的Buffer
        BufferCRBlood,
    }
}
4.加速的Buffer
using UnityEngine;
using System.Collections;

//继承自Buffer基类的,加速的Buffer
public class BufferSpeedUp : BufferStateBase
{
    #region implemented abstract members of BufferStateBase

    //重写基类中进入Buffer的回调
    public override bool OnEnter ()
    {
        UnityEngine.Debug.Log ("进入加速Buffer");
        return true;
    }

    //重写基类中Buffer持续的回调
    public override bool OnUpdate ()
    {
        //CurrArgs.m_ContinuousTime,表示buffer持续时间CurrArgs是BufferArgs类型的
        UnityEngine.Debug.Log ("持续在加速Buffer中, 剩余时间:" + CurrArgs.m_ContinuousTime);
        if ((CurrArgs.m_ContinuousTime -= Time.deltaTime) <= 0) {
            CurrArgs.isOver = true;        //表示会否结束,True表示结束
        }
        return true;
    }

    //重写离开Buffer的回调
    public override bool OnExit ()
    {
        UnityEngine.Debug.Log ("离开了加速Buffer");
        return true;
    }

    //当前Buffer的简述
    public override string CurrBufferInfo {
        get {
            return "这是加速Buffer, 提速为:" + CurrArgs.m_fValue1;
        }
    }

    #endregion
}
5.Buffer控制器
using UnityEngine;
using System.Collections.Generic;
using System;

//Buffer控制器
public class BufferMgr
{
    // 1.该控制器不需要挂载到游戏对象身上
    // 2.和人物控制不同, 不同的buffer之间可以同时工作
    // 3.所以我们需要一个容器, 里面存放所有的buffer状态
    // 4.我们在每一帧, 按照添加的顺序, 不停的调用每一个状态的OnUpdate方法
    // 5.根据状态的m_addition条件来判断是否更新buffer的持续时间

    // 公开的接口
    // 受到buffer系统影响的游戏对象
    public Transform CurrCtrl {
        get;
        set;
    }

    // 构造方法
    public BufferMgr (Transform trans)
    {
        CurrCtrl = trans;
    }

    // Buffer容器
    private List<BufferStateBase> m_bufferList = new List<BufferStateBase> ();

    // 以下方法是我们的设计, 面向用户的
    // 尽可能的全, 并且易于理解和使用

    // 1.添加一个新的Buffer(包括刷新或者重新添加)
    private BufferStateBase BufferCreate (object buffer, BufferArgs bufferArgs)
    {
        //直接创建BufferstateBase类型的变量,于BufferSpeedUp是一样的
        //Activator.CreateInstance创建一个实例
        BufferStateBase newBuffer = 
            Activator.CreateInstance (
                Type.GetType (buffer.ToString ())
            ) 
            as BufferStateBase;

        //具体参数赋值
        newBuffer.CurrArgs = bufferArgs;
        // 控制的游戏对象(前面定义的Buffer影响到的游戏对象)
        newBuffer.CurrCtrl = CurrCtrl;
        //当前Buffer的类型,负面Buffer还是正面Buffer
        newBuffer.CurrBufferType = buffer.GetType ();
        //当前Buffer的具体值
        newBuffer.CurrBurrferState = buffer;

        return newBuffer;
    }

    private void BufferAddBase (object buffer, BufferArgs bufferArgs)
    {
        // 实例化一个Buffer
        BufferStateBase newBuffer = BufferCreate (buffer, bufferArgs);
        // 判断该buffer是否应该添加到容器中
        if (newBuffer.CurrArgs.m_addition == true) {
            // 添加到容器中
            newBuffer.OnEnter ();
            m_bufferList.Add (newBuffer);
        } else {
            // 判断该状态在容器中是否存在
            if (BufferCheckExistsBase (buffer)) { // 存在, 更新作用时间
                //这样用到一个委托(一种缩写形式),在列表里找是否存在Buffer类型的Buffer,然后复制给oldBuffer
                BufferStateBase oldBuffer = m_bufferList.Find (delegate(BufferStateBase obj) {
                    return obj.CurrBurrferState.Equals (buffer);    
                });
                //如果oldBuffer不为空,表示容器中存在了于该Buffer相同的Buffer
                if (oldBuffer != null) {
                    //那么及更新一下作用时间,也就是重新赋一下值
                    oldBuffer.CurrArgs.m_ContinuousTime = newBuffer.CurrArgs.m_ContinuousTime;
                }
            } else { // 不存在, 直接添加进去
                // 添加到容器中
                newBuffer.OnEnter ();
                m_bufferList.Add (newBuffer);
            }
        }
    }

    public void BufferAdd (BufferType.Buffer buffer, BufferArgs bufferArgs)
    {
        // 根据buffer参数创建一个新的BufferStateBase对象
        BufferAddBase (buffer, bufferArgs);
    }

    public void BufferAdd (BufferType.DeBuffer buffer, BufferArgs bufferArgs)
    {
        BufferAddBase (buffer, bufferArgs);
    }

    public void BufferAdd (BufferType.PerBuffer buffer, BufferArgs bufferArgs)
    {
        BufferAddBase (buffer, bufferArgs);
    }

    public void BufferAdd (BufferType.PerDeBuffer buffer, BufferArgs bufferArgs)
    {
        BufferAddBase (buffer, bufferArgs);
    }

    // 2.移除某一种Buffer, 或者某一类Buffer
    private void BufferRemoveBase (object bufferType = null)
    {
        if (bufferType == null) {
            m_bufferList.RemoveAll (delegate(BufferStateBase obj) {
                return (obj.OnExit () || true);
            });
            return;
        }

        // 删除一类Buffer还是删除一个Buffer?
        if ((int)bufferType == 0) {
            m_bufferList.RemoveAll (delegate(BufferStateBase obj) {
                return obj.CurrBufferType.Equals (bufferType.GetType ()) && (obj.OnExit () || true);
            });
        } else {
            m_bufferList.RemoveAll (delegate(BufferStateBase obj) {
                return obj.CurrBurrferState.Equals (bufferType) && (obj.OnExit () || true);
            });
        }
    }

    public void BufferRemove (BufferType.Buffer buffer)
    {
        BufferRemoveBase (buffer);
    }

    public void BufferRemove (BufferType.DeBuffer buffer)
    {
        BufferRemoveBase (buffer);
    }

    public void BufferRemove (BufferType.PerBuffer buffer)
    {
        BufferRemoveBase (buffer);
    }

    public void BufferRemove (BufferType.PerDeBuffer buffer)
    {
        BufferRemoveBase (buffer);
    }

    public void BufferRemove ()
    {
        BufferRemoveBase ();
    }

    // 3.检查某个Buffer是否存在
    private bool BufferCheckExistsBase (object buffer)
    {
        BufferStateBase findBuffer = m_bufferList.Find (delegate(BufferStateBase obj) {
            return obj.CurrBurrferState.Equals (buffer);
        });

        //三目运算符,判断是否存在,存在返回Ture,不存在返回False
        return findBuffer == null ? false : true;
    }

    public bool BufferCheckExists (BufferType.Buffer buffer)
    {
        return BufferCheckExistsBase (buffer);
    }

    public bool BufferCheckExists (BufferType.DeBuffer buffer)
    {
        return BufferCheckExistsBase (buffer);
    }

    public bool BufferCheckExists (BufferType.PerBuffer buffer)
    {
        return BufferCheckExistsBase (buffer);
    }

    public bool BufferCheckExists (BufferType.PerDeBuffer buffer)
    {
        return BufferCheckExistsBase (buffer);
    }

    // 4.驱动OnUpdate的方法
    public void Updata ()
    {
        // 调用每个Buffer的update方法
        m_bufferList.Find (delegate(BufferStateBase obj) {
            return (obj.OnUpdate () || true);    
        });
        // 检查结束的Buffer, 然后移除之
        m_bufferList.RemoveAll (delegate(BufferStateBase obj) {
            return obj.CurrArgs.isOver == true && (obj.OnExit () || true);
        });
    }
}
6.Buffer管理,挂在游戏对象身上
using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour
{

    public BufferMgr m_bufferMgr;        //接受一个Buffer控制器

    void Start ()
    {
        m_bufferMgr = new BufferMgr (transform);
    }

    void Update ()
    {
        //每帧调用依次Update
        m_bufferMgr.Updata ();

        if (Input.GetKeyDown (KeyCode.Alpha1)) {
            BufferArgs args = new BufferArgs ();
            args.m_fValue1 = 0.2f;
            args.m_addition = false;
            args.m_ContinuousTime = 3;
            m_bufferMgr.BufferAdd (BufferType.Buffer.BufferSpeedUp, args);        
        }
        if (Input.GetKeyDown (KeyCode.Alpha2)) {
            m_bufferMgr.BufferRemove (BufferType.Buffer.BufferSpeedUp);    
        }
        if (Input.GetKeyDown (KeyCode.Alpha3)) {
            m_bufferMgr.BufferRemove ();            
        }
    }
}










### Analog-to-Digital Converter Reference Buffer Design and Implementation The concept of an analog-to-digital converter (ADC) reference buffer is crucial for ensuring accurate voltage levels during the conversion process. The reference buffer plays a significant role in stabilizing the input signal to prevent distortion caused by variations in load impedance or other external factors. In the context of ADCs, the **reference buffer** acts as an intermediary between the power supply and the internal circuitry of the ADC. This ensures that any fluctuations in the power source do not directly affect the precision of the digital output values[^1]. For instance, when designing such buffers using differential techniques, one can refer to specific implementations like those described under 'Analog Differential Buffer Delay Element' which provide insights into minimizing delays while maintaining high accuracy. Additionally, fully digital delta-sigma modulators used within some modern converters also incorporate similar principles where they rely heavily upon precise timing mechanisms provided through well-designed buffering systems [^2]. These designs often include features aimed at reducing noise interference from adjacent circuits thereby enhancing overall performance metrics including Signal Noise Ratio(SNR). From another perspective regarding practical applications involving embedded platforms there exist numerous resources detailing various aspects related specifically towards developing robust solutions incorporating these concepts effectively without compromising efficiency nor reliability standards set forth today's demanding technological landscape.[^3] ```c // Example Code Showing Basic Structure For Implementing A Simple Voltage Follower As Part Of An ADC Ref Buffer System In C Language. #include <stdio.h> #define VREF 3.3 // Define your desired reference voltage here float calculate_output(float vin){ float vout; if(vin>VREF){vout=VREF;} else{vout=vin;} return vout; } int main(){ printf("Output Voltage:%f\n",calculate_output(2.5)); } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值