private Vector2 InternalDecrypt()
{
if (!inited)
{
currentCryptoKey = cryptoKey;
hiddenValue = Encrypt(initialFakeValue);
fakeValue = initialFakeValue;
inited = true;
}
int key = cryptoKey;
if (currentCryptoKey != cryptoKey)
{
key = currentCryptoKey;
}
Vector2 value;
value.x = ObscuredFloat.Decrypt(hiddenValue.x, key);
value.y = ObscuredFloat.Decrypt(hiddenValue.y, key);
if (Detectors.ObscuredCheatingDetector.isRunning && !fakeValue.Equals(initialFakeValue) && !CompareVectorsWithTolerance(value, fakeValue))
{
Detectors.ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return(value);
}
private Vector3 InternalDecrypt()
{
if (!inited)
{
currentCryptoKey = cryptoKey;
hiddenValue = Encrypt(initialFakeValue, cryptoKey);
inited = true;
}
int key = cryptoKey;
if (currentCryptoKey != cryptoKey)
{
key = currentCryptoKey;
}
Vector3 value;
value.x = ObscuredFloat.Decrypt(hiddenValue.x, key);
value.y = ObscuredFloat.Decrypt(hiddenValue.y, key);
value.z = ObscuredFloat.Decrypt(hiddenValue.z, key);
return(value);
}
private Vector3 InternalDecrypt()
{
if (!inited)
{
currentCryptoKey = cryptoKey;
hiddenValue = Encrypt(zero, cryptoKey);
fakeValue = zero;
fakeValueActive = false;
inited = true;
return(zero);
}
Vector3 value;
value.x = ObscuredFloat.Decrypt(hiddenValue.x, currentCryptoKey);
value.y = ObscuredFloat.Decrypt(hiddenValue.y, currentCryptoKey);
value.z = ObscuredFloat.Decrypt(hiddenValue.z, currentCryptoKey);
if (Detectors.ObscuredCheatingDetector.IsRunning && fakeValueActive && !CompareVectorsWithTolerance(value, fakeValue))
{
Detectors.ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return(value);
}
private Quaternion InternalDecrypt()
{
if (!inited)
{
currentCryptoKey = cryptoKey;
hiddenValue = Encrypt(identity);
fakeValue = identity;
fakeValueActive = false;
inited = true;
return(identity);
}
Quaternion value;
value.x = ObscuredFloat.Decrypt(hiddenValue.x, currentCryptoKey);
value.y = ObscuredFloat.Decrypt(hiddenValue.y, currentCryptoKey);
value.z = ObscuredFloat.Decrypt(hiddenValue.z, currentCryptoKey);
value.w = ObscuredFloat.Decrypt(hiddenValue.w, currentCryptoKey);
if (Detectors.ObscuredCheatingDetector.ExistsAndIsRunning && fakeValueActive && !CompareQuaternionsWithTolerance(value, fakeValue))
{
Detectors.ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return(value);
}
/// <summary>
/// Decrypts passed value you got from Encrypt() using same key.
/// </summary>
/// \sa Encrypt()
public static Vector2 Decrypt(RawEncryptedVector2 value, int key)
{
Vector2 result;
result.x = ObscuredFloat.Decrypt(value.x, key);
result.y = ObscuredFloat.Decrypt(value.y, key);
return(result);
}
private float InternalDecryptField(int encrypted)
{
int key = ObscuredVector3.cryptoKey;
if (this.currentCryptoKey != ObscuredVector3.cryptoKey)
{
key = this.currentCryptoKey;
}
return(ObscuredFloat.Decrypt(encrypted, key));
}
public static Vector2 DecryptDeprecated(Vector2 value, int key)
{
if (key == 0)
{
key = cryptoKey;
}
value.x = ObscuredFloat.Decrypt((int)value.x, key);
return(value);
}
/// <summary>
/// Decrypts passed value you got from Encrypt() using same key.
/// </summary>
/// \sa Encrypt()
public static Quaternion Decrypt(RawEncryptedQuaternion value, int key)
{
Quaternion result;
result.x = ObscuredFloat.Decrypt(value.x, key);
result.y = ObscuredFloat.Decrypt(value.y, key);
result.z = ObscuredFloat.Decrypt(value.z, key);
result.w = ObscuredFloat.Decrypt(value.w, key);
return(result);
}
public static Vector2 Decrypt(ObscuredVector2.RawEncryptedVector2 value, int key)
{
if (key == 0)
{
key = ObscuredVector2.cryptoKey;
}
Vector2 vector2;
vector2.x = (__Null)(double)ObscuredFloat.Decrypt(value.x, key);
vector2.y = (__Null)(double)ObscuredFloat.Decrypt(value.y, key);
return(vector2);
}
public static Vector2 Decrypt(ObscuredVector2.RawEncryptedVector2 value, int key)
{
if (key == 0)
{
key = ObscuredVector2.cryptoKey;
}
Vector2 result;
result.x = ObscuredFloat.Decrypt(value.x, key);
result.y = ObscuredFloat.Decrypt(value.y, key);
return(result);
}
public static Quaternion Decrypt(ObscuredQuaternion.RawEncryptedQuaternion value, int key)
{
if (key == 0)
{
key = ObscuredQuaternion.cryptoKey;
}
Quaternion result;
result.x = ObscuredFloat.Decrypt(value.x, key);
result.y = ObscuredFloat.Decrypt(value.y, key);
result.z = ObscuredFloat.Decrypt(value.z, key);
result.w = ObscuredFloat.Decrypt(value.w, key);
return result;
}
private float InternalDecryptField(int encrypted)
{
int key = cryptoKey;
if (currentCryptoKey != cryptoKey)
{
key = currentCryptoKey;
}
float result = ObscuredFloat.Decrypt(encrypted, key);
return(result);
}
public static Vector3 Decrypt(ObscuredVector3.RawEncryptedVector3 value, int key)
{
if (key == 0)
{
key = ObscuredVector3.cryptoKey;
}
Vector3 vector3;
vector3.x = (__Null)(double)ObscuredFloat.Decrypt(value.x, key);
vector3.y = (__Null)(double)ObscuredFloat.Decrypt(value.y, key);
vector3.z = (__Null)(double)ObscuredFloat.Decrypt(value.z, key);
return(vector3);
}
public static Quaternion Decrypt(ObscuredQuaternion.RawEncryptedQuaternion value, int key)
{
if (key == 0)
{
key = ObscuredQuaternion.cryptoKey;
}
Quaternion quaternion;
quaternion.x = (__Null)(double)ObscuredFloat.Decrypt(value.x, key);
quaternion.y = (__Null)(double)ObscuredFloat.Decrypt(value.y, key);
quaternion.z = (__Null)(double)ObscuredFloat.Decrypt(value.z, key);
quaternion.w = (__Null)(double)ObscuredFloat.Decrypt(value.w, key);
return(quaternion);
}
public static Quaternion DecryptDeprecated(Quaternion value, int key)
{
if (key == 0)
{
key = cryptoKey;
}
value.x = ObscuredFloat.Decrypt((int)value.x, key);
value.y = ObscuredFloat.Decrypt((int)value.y, key);
value.z = ObscuredFloat.Decrypt((int)value.z, key);
value.w = ObscuredFloat.Decrypt((int)value.w, key);
return(value);
}
/// <summary>
/// Use it to decrypt RawEncryptedVector3 you got from Encrypt(), uses passed crypto key.
/// </summary>
public static Vector3 Decrypt(RawEncryptedVector3 value, int key)
{
if (key == 0)
{
key = cryptoKey;
}
Vector3 result;
result.x = ObscuredFloat.Decrypt(value.x, key);
result.y = ObscuredFloat.Decrypt(value.y, key);
result.z = ObscuredFloat.Decrypt(value.z, key);
return(result);
}
private Vector2 InternalDecrypt()
{
if (!this.inited)
{
this.currentCryptoKey = ObscuredVector2.cryptoKey;
this.hiddenValue = ObscuredVector2.Encrypt(ObscuredVector2.initialFakeValue);
this.fakeValue = ObscuredVector2.initialFakeValue;
this.inited = true;
}
Vector2 vector;
vector.x = ObscuredFloat.Decrypt(this.hiddenValue.x, this.currentCryptoKey);
vector.y = ObscuredFloat.Decrypt(this.hiddenValue.y, this.currentCryptoKey);
if (ObscuredCheatingDetector.IsRunning && !this.fakeValue.Equals(ObscuredVector2.initialFakeValue) && !this.CompareVectorsWithTolerance(vector, this.fakeValue))
{
ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return(vector);
}
private Vector2 InternalDecrypt()
{
if (!this.inited)
{
this.currentCryptoKey = ObscuredVector2.cryptoKey;
this.hiddenValue = ObscuredVector2.Encrypt(ObscuredVector2.initialFakeValue);
this.fakeValue = ObscuredVector2.initialFakeValue;
this.inited = true;
}
Vector2 vector1;
vector1.x = (__Null)(double)ObscuredFloat.Decrypt(this.hiddenValue.x, this.currentCryptoKey);
vector1.y = (__Null)(double)ObscuredFloat.Decrypt(this.hiddenValue.y, this.currentCryptoKey);
// ISSUE: explicit reference operation
if (ObscuredCheatingDetector.IsRunning && !((Vector2)@this.fakeValue).Equals((object)ObscuredVector2.initialFakeValue) && !this.CompareVectorsWithTolerance(vector1, this.fakeValue))
{
ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return(vector1);
}
private Quaternion InternalDecrypt()
{
if (!this.inited)
{
this.currentCryptoKey = ObscuredQuaternion.cryptoKey;
this.hiddenValue = ObscuredQuaternion.Encrypt(ObscuredQuaternion.initialFakeValue);
this.fakeValue = ObscuredQuaternion.initialFakeValue;
this.inited = true;
}
Quaternion quaternion;
quaternion.x = ObscuredFloat.Decrypt(this.hiddenValue.x, this.currentCryptoKey);
quaternion.y = ObscuredFloat.Decrypt(this.hiddenValue.y, this.currentCryptoKey);
quaternion.z = ObscuredFloat.Decrypt(this.hiddenValue.z, this.currentCryptoKey);
quaternion.w = ObscuredFloat.Decrypt(this.hiddenValue.w, this.currentCryptoKey);
if (ObscuredCheatingDetector.IsRunning && !this.fakeValue.Equals(ObscuredQuaternion.initialFakeValue) && !this.CompareQuaternionsWithTolerance(quaternion, this.fakeValue))
{
ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return quaternion;
}
private Quaternion InternalDecrypt()
{
if (!this.inited)
{
this.currentCryptoKey = ObscuredQuaternion.cryptoKey;
this.hiddenValue = ObscuredQuaternion.Encrypt(ObscuredQuaternion.initialFakeValue);
this.fakeValue = ObscuredQuaternion.initialFakeValue;
this.inited = true;
}
Quaternion q1;
q1.x = (__Null)(double)ObscuredFloat.Decrypt(this.hiddenValue.x, this.currentCryptoKey);
q1.y = (__Null)(double)ObscuredFloat.Decrypt(this.hiddenValue.y, this.currentCryptoKey);
q1.z = (__Null)(double)ObscuredFloat.Decrypt(this.hiddenValue.z, this.currentCryptoKey);
q1.w = (__Null)(double)ObscuredFloat.Decrypt(this.hiddenValue.w, this.currentCryptoKey);
// ISSUE: explicit reference operation
if (ObscuredCheatingDetector.IsRunning && !((Quaternion)@this.fakeValue).Equals((object)ObscuredQuaternion.initialFakeValue) && !this.CompareQuaternionsWithTolerance(q1, this.fakeValue))
{
ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return(q1);
}
private Quaternion InternalDecrypt()
{
if (!inited)
{
currentCryptoKey = cryptoKey;
hiddenValue = Encrypt(initialFakeValue);
fakeValue = initialFakeValue;
inited = true;
}
Quaternion value;
value.x = ObscuredFloat.Decrypt(hiddenValue.x, currentCryptoKey);
value.y = ObscuredFloat.Decrypt(hiddenValue.y, currentCryptoKey);
value.z = ObscuredFloat.Decrypt(hiddenValue.z, currentCryptoKey);
value.w = ObscuredFloat.Decrypt(hiddenValue.w, currentCryptoKey);
if (Detectors.ObscuredCheatingDetector.IsRunning && !fakeValue.Equals(initialFakeValue) && !CompareQuaternionsWithTolerance(value, fakeValue))
{
Detectors.ObscuredCheatingDetector.Instance.OnCheatingDetected();
}
return(value);
}
