enconvert.c

Go to the documentation of this file.

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;
 }
 
 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();
};
 
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;
 }
 
 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]);
 }
};
 
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 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 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;
 }
}