test/Assets/PerfectWorld/Scripts/Managers/EC_Object.cs

using CSNetwork.GPDataType;
using CSNetwork.Protocols;
using UnityEngine;

///////////////////////////////////////////////////////////////////////////
//	
//	Class CECObject
//	
///////////////////////////////////////////////////////////////////////////

public class CECObject : MonoBehaviour
{
    //	Class ID
    public static class Class_ID
    {
        public const int OCID_OBJECT = 0,
        OCID_PLAYER = 1,
        OCID_HOSTPLAYER = 2,
        OCID_ELSEPLAYER = 3,
        OCID_LOGINPLAYER = 4,
        OCID_NPC = 5,
        OCID_MONSTER = 6,
        OCID_SERVER = 7,
        OCID_MATTER = 8,
        OCID_PET = 9,
        OCID_CLONED_PLAYER = 10,     //	复制角色模型
        OCID_HOST_NAVIGATER = 11,    //	纯客户端player类,用于强制移动
        OCID_NPCCLONED_MASTER = 12;  //	NPC 复制的角色模型
    }

    //	Render flag
    public static class Render_flag
    {
        public const int RD_NORMAL = 0,
        RD_REFRACT = 1,
        RD_REFLECT = 2;
    }

    //	Move environment
    public static class Move_environment
    {
        public const int MOVEENV_GROUND = 0, //	Move on ground
        MOVEENV_WATER = 1,
        MOVEENV_AIR = 2;
    }

    //	Constructor and Destructor
    public CECObject()
    {
        m_iCID = Class_ID.OCID_OBJECT;
        m_bAdjustOrient = false;
        m_bVisible = true;
        m_bBornInSight = false;
        m_dwBornStamp = 0;

        m_bUseGroundNormal = false;
        m_vecGroundNormal = new A3DVECTOR3(0.0f, 1.0f, 0.0f);
        m_vecGroundNormalSet = new A3DVECTOR3(0.0f, 1.0f, 0.0f);

        m_bSelectable = true;
    }

    public virtual void SetUpCECObject()
    {
        m_dwBornStamp = 0;
        m_bBornInSight = false;
        m_bSelectable = false;
        m_iCID = (int)Class_ID.OCID_OBJECT;
    }

    public void SetSelectable(bool bSelectable) { m_bSelectable = bSelectable; }

    //	Tick routine
    public bool Tick(float dwDeltaTime)
    {
        if (m_bAdjustOrient)
            AdjustOrientation(dwDeltaTime);

        m_vecGroundNormal = Normalize(m_vecGroundNormal * 0.85f + m_vecGroundNormalSet * 0.15f);
        return true;
    }

    //	Set absolute forward and up direction
    public virtual void SetDirAndUp(A3DVECTOR3 vDir, A3DVECTOR3 vUp)
    {
        if (m_bUseGroundNormal)
        {
            A3DVECTOR3 vecRight = Normalize(CrossProduct(g_vAxisY, vDir));
            A3DVECTOR3 vecNormal = m_vecGroundNormal - DotProduct(m_vecGroundNormal, vecRight) * vecRight;
            A3DVECTOR3 vecNewDir = Normalize(CrossProduct(vecRight, vecNormal));
            A3DCoordinate::SetDirAndUp(vecNewDir, vecNormal);
        }
        else
            A3DCoordinate::SetDirAndUp(vDir, vUp);

        //	Stop orientation adjusting
        m_bAdjustOrient = false;
    }
    //	Set destination orientation of model
    public void SetDestDirAndUp(A3DVECTOR3 vDir, A3DVECTOR3 vUp, float dwTime)
    {
        m_bAdjustOrient = true;
        m_dwOrientTime = dwTime;
        m_dwOrientTimeCnt = 0;

        //	Calculate start orientation
        A3DMATRIX4 mat = a3d_TransformMatrix(GetDir(), GetUp(), g_vOrigin);
        m_quOrientStart.ConvertFromMatrix(mat);

        //	Calculate end orientation
        if (m_bUseGroundNormal)
        {
            A3DVECTOR3 vecRight = Normalize(CrossProduct(g_vAxisY, vDir));
            A3DVECTOR3 vecNormal = m_vecGroundNormal - DotProduct(m_vecGroundNormal, vecRight) * vecRight;
            A3DVECTOR3 vecNewDir = Normalize(CrossProduct(vecRight, vecNormal));
            mat = a3d_TransformMatrix(vecNewDir, vecNormal, g_vOrigin);
        }
        else
        {
            mat = a3d_TransformMatrix(vDir, vUp, g_vOrigin);
        }

        m_quOrientEnd.ConvertFromMatrix(mat);
    }

    //	Calculate distance between this object and specified position
    public float CalcDist(A3DVECTOR3 vPos, bool b3D)
    {
        A3DVECTOR3 vDelta = GetPos() - vPos;
        return b3D ? vDelta.Magnitude() : vDelta.MagnitudeH();
    }

    private A3DVECTOR3 Normalize(A3DVECTOR3 v)
    {
        float mag = v.Magnitude();
        if (mag < 1e-12 && mag > -1e-12)
            return new A3DVECTOR3(0.0f);
        else
            return v / mag;
    }

    public A3DVECTOR3 GetPos()
    {
        return new A3DVECTOR3(transform.position.x, transform.position.y, transform.position.z);
    }

    //	Turn around object and face to specified object
    public virtual void TurnFaceTo(int idTarget, float dwTime = 200)
    {

    }

    //	Set / Get visible flag
    public void SetVisible(bool bVisible) 
    { 
        m_bVisible = bVisible; 
    }
    public bool GetVisible() 
    { 
        return m_bVisible; 
    }

    //	Get object class ID
    public int GetClassID() { return m_iCID; }
	public bool IsPlayer() { return m_iCID == Class_ID.OCID_HOSTPLAYER || m_iCID == Class_ID.OCID_ELSEPLAYER || m_iCID == Class_ID.OCID_LOGINPLAYER; }
	public bool IsHostPlayer() { return m_iCID == Class_ID.OCID_HOSTPLAYER; }
	public bool IsElsePlayer() { return m_iCID == Class_ID.OCID_ELSEPLAYER; }
	public bool IsLoginPlayer(){ return m_iCID == Class_ID.OCID_LOGINPLAYER; }
	public bool IsNPC() { return m_iCID == Class_ID.OCID_MONSTER || m_iCID == Class_ID.OCID_SERVER; }
	public bool IsMonsterNPC() { return m_iCID == Class_ID.OCID_MONSTER; }
	public bool IsServerNPC() { return m_iCID == Class_ID.OCID_SERVER; }
	public bool IsMatter() { return m_iCID == Class_ID.OCID_MATTER; }
	public bool IsSelectable() { return m_bSelectable; }
	//	Set / Get object born stamp
	public uint GetBornStamp() { return m_dwBornStamp; }
	public void SetBornStamp(uint dwStamp) { m_dwBornStamp = dwStamp; }
    //	Set / Get born in sight flag
    public bool GetBornInSight() { return m_bBornInSight; }
	public void SetBornInSight(bool bFlag) { m_bBornInSight = bFlag; }

    //	Get object id
    public static int GetObjectID(CECObject pObject)
    {

    }

	protected int m_iCID;             //	Class ID
    protected bool m_bAdjustOrient;   //	Is adjusting orientation
    protected A3DQUATERNION m_quOrientStart;  //	Orientation start
    protected A3DQUATERNION m_quOrientEnd;        //	Orientation end
    protected float m_dwOrientTime;       //	Orientation adjusting time counter
    protected uint m_dwOrientTimeCnt;    //	Orientation adjusting time counter

    protected bool m_bBornInSight;        //	Born in my sight
    protected uint m_dwBornStamp;        //	Born time stamp
    protected bool m_bVisible;            //	Render flag

    protected bool m_bUseGroundNormal;    //	flag indicates whether we use a ground normal as up
    protected A3DVECTOR3 m_vecGroundNormal;   //	current ground normal
    protected A3DVECTOR3 m_vecGroundNormalSet;    //	ground normal set

    protected bool m_bSelectable;       // whether the object can be selected

    public inline const A3DVECTOR3& GetGroundNormal()const			{ return m_vecGroundNormal; }
	public inline bool GetUseGroundNormal()const					{ return m_bUseGroundNormal; }

	public void SetUseGroundNormal(bool bFlag)
    {

    }
    public void SetGroundNormal(A3DVECTOR3 vecNormal)
    {

    }

	protected void AdjustOrientation(float dwDeltaTime)
    {

    }
}