EnConvert.c

См. документацию.

class bool
{
    string ToString()
    {
        if (value) return "true";
        else return "false";
    }
};
 
class func
{
    private proto void SetInstance(Class inst);
};
 
enum EBool
{
    NO = 0,
    YES = 1  
}
 
class int
{
    protected const int ZERO_PAD_SIZE = 8;
    protected static string m_ZeroPad[ZERO_PAD_SIZE] = {"", "0", "00", "000", "0000", "00000", "000000", "0000000"};
    
    const int MAX = 2147483647;
    const int MIN = -2147483648;
    
    proto string ToString();
    
    proto string AsciiToString();
    
    string ToStringLen(int len)
    {
        string str = value.ToString();
 
        int l = len - str.Length();
 
        if (l > 0 && l < ZERO_PAD_SIZE )
            return m_ZeroPad[l] + str;
 
        return str;
    }

    proto string ToHex();
    
    bool InRange( int min, int max, bool inclusive_min = true, bool inclusive_max = true )
    {
        if( ( !inclusive_min && value <= min ) || value < min )
            return false;
        
        if( ( !inclusive_max && value >= max ) || value > max )
            return false;
        
        return true;
    }
};
 
class float
{
    const float MIN = FLT_MIN;
    const float MAX = FLT_MAX;
    const float LOWEST = -FLT_MAX;
    
    proto string ToString(bool simple = true);
};
 
class vector
{
    static const vector Up = "0 1 0";
    static const vector Aside = "1 0 0";
    static const vector Forward = "0 0 1";
    static const vector Zero = "0 0 0";
    
    proto string ToString(bool beautify = true);
    
    proto float Normalize();

    proto vector Normalized();
    
    proto native float Length();

    proto native float LengthSq();
    
    proto static native float Distance(vector v1, vector v2);
    
    proto static native float DistanceSq(vector v1, vector v2);

    vector Perpend()
    {
        return value * vector.Up;
    }

    vector Cross(vector v)
    {
        float x = value[1] * v[2] - value[2] * v[1];
        float y = value[2] * v[0] - value[0] * v[2];
        float z = value[0] * v[1] - value[1] * v[0];
 
        return Vector(x, y, z);
    }
    
    static vector Direction(vector p1, vector p2)
    {
        vector dir_vec;
        
        dir_vec[0] = p2[0] - p1[0];
        dir_vec[1] = p2[1] - p1[1];
        dir_vec[2] = p2[2] - p1[2];
        
        return dir_vec;
    }
    
    static vector RandomDir()
    {
        return Vector(Math.RandomFloatInclusive(-1,1),Math.RandomFloatInclusive(-1,1),Math.RandomFloatInclusive(-1,1)).Normalized();
    }

    static vector RandomDir2D()
    {
        return Vector(Math.RandomFloatInclusive(-1,1),0,Math.RandomFloatInclusive(-1,1)).Normalized();
    }
    
    static float Dot(vector v1, vector v2)
    {
        return ((v1[0] * v2[0]) + (v1[1] * v2[1]) + (v1[2] * v2[2]));
    }

    vector GetRelAngles()
    {
        for(int i = 0; i < 3; i++) {
            if(value[i] > 180)
                value[i] = value[i] - 360;
            if(value[i] < -180)
                value[i] = value[i] + 360;
        }
        return value;
    }
    
    proto float VectorToYaw();

    proto native static vector YawToVector(float yaw);

    proto vector VectorToAngles();

    proto vector AnglesToVector();

    proto void RotationMatrixFromAngles(out vector mat[3]);
    
    proto vector Multiply4(vector mat[4]);

    proto vector Multiply3(vector mat[3]);

    proto vector InvMultiply4(vector mat[4]);

    proto vector InvMultiply3(vector mat[3]);
    
    proto static native vector Lerp(vector v1, vector v2, float t);
    
    
    static vector RotateAroundZeroDeg(vector vec, vector axis, float angle)
    {
        return (vec * Math.Cos(angle * Math.DEG2RAD)) + ((axis * vec) * Math.Sin(angle * Math.DEG2RAD)) + (axis * vector.Dot(axis, vec)) * (1 - Math.Cos(angle * Math.DEG2RAD));
    }
    
    
    static vector RotateAroundZeroRad(vector vec, vector axis, float angle)
    {
        return (vec * Math.Cos(angle)) + ((axis * vec) * Math.Sin(angle)) + (axis * vector.Dot(axis, vec)) * (1 - Math.Cos(angle));
    }
    
    
    static vector RotateAroundZero(vector pos, vector axis, float cosAngle, float sinAngle)
    {
        return (pos * cosAngle) + ((axis * pos) * sinAngle) + (axis * vector.Dot(axis, pos)) * (1 - cosAngle);
    }
    
    static vector RotateAroundPoint(vector point, vector pos, vector axis, float cosAngle, float sinAngle)
    {
        vector offsetPos = pos - point;
        return RotateAroundZero(offsetPos, axis, cosAngle, sinAngle) + point;
    }
    
    static vector ArrayToVec(float arr[])
    {
        return Vector(arr[0], arr[1], arr[2]);
    }
    
    static void SanitizeMinsMaxs(inout vector min, inout vector max)
    {
        vector minTmp, maxTmp;
        minTmp[0] = Math.Min(min[0],max[0]);
        maxTmp[0] = Math.Max(min[0],max[0]);
        minTmp[1] = Math.Min(min[1],max[1]);
        maxTmp[1] = Math.Max(min[1],max[1]);
        minTmp[2] = Math.Min(min[2],max[2]);
        maxTmp[2] = Math.Max(min[2],max[2]);
        min = minTmp;
        max = maxTmp;
    }
};
 
class typename
{
    proto volatile Class Spawn();
    
    proto owned string GetModule();
    
    proto native owned string ToString();
    
    proto native bool IsInherited(typename baseType);
    
    proto native int GetVariableCount();
    proto native owned string GetVariableName(int vIdx);
    proto native typename GetVariableType(int vIdx);
    proto bool GetVariableValue(Class var, int vIdx, out void val);
    
    static string EnumToString(typename e, int enumValue)
    {
        int cnt = e.GetVariableCount();
        int val;
 
        for (int i = 0; i < cnt; ++i)
        {
            if (e.GetVariableType(i) == int && e.GetVariableValue(null, i, val) && val == enumValue)
            {
                return e.GetVariableName(i);
            }
        }
                
        return "unknown";
    }
    
    static string EnumFlagsToString(typename enumType, int value)
    {
        // Exact match first (non-flags and exact declared combinations)
        string exact = enumType.EnumToString(enumType, value);
        if (exact != "unknown")
            return exact;
    
        // unknown handlind
        if (value == 0)
        {
            string zeroName = enumType.EnumToString(enumType, 0);
            if (zeroName != string.Empty)
                return zeroName;
            else
                return "unknown";
        }
    
        // Iterate bits and resolve each flag name
        int remaining = value;
        array<string> parts = {};
        int bit = 1;
    
        // keep within 32-bit enums
        for (int i = 0; i < 32 && remaining != 0; ++i)
        {
            bit <<= 1;
            if ((value & bit) != 0)
            {
                string name = enumType.EnumToString(enumType, bit);
                if (name != "unknown")
                {
                    parts.Insert(name);
                    remaining &= ~bit;
                }
            }
        }
    
        // If we couldn't map all bits, include the unknown residue in hex
        if (remaining != 0)
            parts.Insert(string.Format("0x%1", remaining.ToHex()));
    
        if (parts.Count() == 0)
        {
            // Nothing mapped; last resort: hex of the original value
            return string.Format("0x%1", value.ToHex());
        }
    
        return string.Join("|", parts);
    }
    
    static int StringToEnum(typename e, string enumName)
    {
        int count = e.GetVariableCount();
        int value;
       
        for (int i = 0; i < count; ++i)
        {
            if (e.GetVariableType(i) == int && e.GetVariableValue(null, i, value) && e.GetVariableName(i) == enumName)
            {
                return value;
            }
        }
        
        return -1;
    }
};
 
class EnumTools
{
    private void EnumTools();
    private void ~EnumTools();
    
    static string EnumToString(typename e, int enumValue)
    {
        return typename.EnumToString(e, enumValue);
    }
    
    static string EnumFlagsToString(typename enumType, int enumValue)
    {
        return typename.EnumFlagsToString(enumType, enumValue);
    }
    
    static int StringToEnum(typename e, string enumName)
    {
        return typename.StringToEnum(e, enumName);
    }
    
    static int GetEnumSize(typename e)
    {
        return e.GetVariableCount();
    }
    
    static int GetEnumValue(typename e, int idx)
    {
        int value;
        e.GetVariableValue(null, idx, value);       
        return value;
    }
    
    static int GetLastEnumValue(typename e)
    {
        int lastValue;
        e.GetVariableValue(null, e.GetVariableCount() - 1, lastValue);      
        return lastValue;
    }
}