// Token: 0x06001C0D RID: 7181 RVA: 0x0008EE20 File Offset: 0x0008D020
private IEnumerator StartNewSpeedhackDetection()
{
yield return(new WaitForSeconds(5f));
CheatDetection.SyncSystemTime();
LimitedQueue <float> timeDifference = new LimitedQueue <float>(5);
for (;;)
{
yield return(new WaitForSeconds(5f));
if (GameState.Current.HasJoinedGame)
{
timeDifference.Enqueue((float)this.GameTime / (float)this.RealTime);
CheatDetection.SyncSystemTime();
if (timeDifference.Count == 5)
{
float avg = this.averageSpeedHackResults(timeDifference);
if (avg != -1f)
{
if ((double)avg >= 0.75)
{
break;
}
timeDifference.Clear();
}
}
}
}
AutoMonoBehaviour <CommConnectionManager> .Instance.Client.Lobby.Operations.SendSpeedhackDetectionNew(timeDifference.ToList <float>());
yield break;
}
private bool CheckForDoubleClap()
{
int nrOfClaps = 0;
int wait = 0;
foreach (Hands hands in _history)
{
if (wait > 0)
{
wait--;
}
else if (hands.DetectClap())
{
nrOfClaps++;
wait = 4;
}
}
if (nrOfClaps >= 2)
{
_history.Clear();
return(true);
}
return(false);
}
public void LimitedQueue_AutoDisposeSized()
{
LimitedQueue <SizedDisposable> queue = new LimitedQueue <SizedDisposable>();
SizedDisposable v0 = new SizedDisposable(0, 3);
SizedDisposable v1 = new SizedDisposable(1, 3);
SizedDisposable v2 = new SizedDisposable(2, 3);
SizedDisposable v3 = new SizedDisposable(3, 3);
Assert.IsFalse(queue.AutoDispose);
queue.SizeLimit = 10;
queue.Enqueue(v0);
queue.Enqueue(v1);
queue.Enqueue(v2);
queue.Enqueue(v3);
Assert.AreEqual(3, queue.Count);
Assert.IsFalse(v0.IsDisposed);
Assert.AreEqual(1, queue.Dequeue().Value);
queue.Clear();
Assert.IsFalse(v1.IsDisposed);
Assert.IsFalse(v2.IsDisposed);
Assert.IsFalse(v3.IsDisposed);
queue.AutoDispose = true;
queue.Enqueue(v0);
queue.Enqueue(v1);
queue.Enqueue(v2);
queue.Enqueue(v3);
Assert.AreEqual(3, queue.Count);
Assert.IsTrue(v0.IsDisposed);
Assert.AreEqual(1, queue.Dequeue().Value);
queue.Clear();
Assert.IsFalse(v1.IsDisposed);
Assert.IsTrue(v2.IsDisposed);
Assert.IsTrue(v3.IsDisposed);
}
public void LimitedQueue_AutoDispose()
{
LimitedQueue <PlainDisposable> queue = new LimitedQueue <PlainDisposable>();
PlainDisposable v0 = new PlainDisposable(0);
PlainDisposable v1 = new PlainDisposable(1);
PlainDisposable v2 = new PlainDisposable(2);
PlainDisposable v3 = new PlainDisposable(3);
Assert.IsFalse(queue.AutoDispose);
queue.CountLimit = 3;
queue.Enqueue(v0);
queue.Enqueue(v1);
queue.Enqueue(v2);
queue.Enqueue(v3);
Assert.AreEqual(3, queue.Count);
Assert.IsFalse(v0.IsDisposed);
Assert.AreEqual(1, queue.Dequeue().Value);
queue.Clear();
Assert.IsFalse(v1.IsDisposed);
Assert.IsFalse(v2.IsDisposed);
Assert.IsFalse(v3.IsDisposed);
queue.AutoDispose = true;
queue.Enqueue(v0);
queue.Enqueue(v1);
queue.Enqueue(v2);
queue.Enqueue(v3);
Assert.AreEqual(3, queue.Count);
Assert.IsTrue(v0.IsDisposed);
Assert.AreEqual(1, queue.Dequeue().Value);
queue.Clear();
Assert.IsFalse(v1.IsDisposed);
Assert.IsTrue(v2.IsDisposed);
Assert.IsTrue(v3.IsDisposed);
}
public void LimitedQueue_Basic()
{
LimitedQueue <int> queue = new LimitedQueue <int>();
Assert.AreEqual(0, queue.Count);
queue.Enqueue(0);
Assert.AreEqual(1, queue.Count);
queue.Enqueue(1);
Assert.AreEqual(2, queue.Count);
Assert.AreEqual(0, queue.Dequeue());
Assert.AreEqual(1, queue.Dequeue());
queue.Clear();
Assert.AreEqual(0, queue.Count);
}
public virtual void Close()
{
netState = NetState.None;
sequence = 0;
ack = 0;
ackbit = 0;
quantics.Clear();
cacheSend.Clear();
cacheReceived.Clear();
cacheLost.Clear();
lastConnectTime = lastReceviedTime = DateTime.MinValue;
connectTimes = 0;
sends.Clear();
receives.Clear();
try
{
if (rc != null)
{
rc.Close();
}
}
catch (Exception ecp)
{
Debug.LogError(ecp.Message + "\n" + ecp.StackTrace);
}
try
{
if (sc != null)
{
sc.Close();
}
}
catch (Exception ecp)
{
Debug.LogError(ecp.Message + "\n" + ecp.StackTrace);
}
rc = null;
sc = null;
ep = null;
}
private Semaphore CheckForSemafoor()
{
Semaphore detectedSemaphore = null;
lock (_syncRoot)
{
if (_history == null || _history.Count == 0)
{
return(null);
}
Semaphore check = _history.Peek();
int count = _history.AsParallel().Count(s => null != s && s.Equals(check));
if (count == _history.Count)
{
////TODO: dit zo nog even controleren
detectedSemaphore = check;
_history.Clear();
}
}
return(detectedSemaphore);
}
public void Jump()
{
groundQueue.Clear();
jumpSlider.value = virtualController.Time_Hold_Button_A / jumpSlider.maxValue;
boostedJumpPower = 1;
StartCoroutine(OnJump());
wasJump = true;
boostedJumpPower = virtualController.Time_Hold_Button_A;
if (boostedJumpPower > maxJumpBoost)
{
boostedJumpPower = maxJumpBoost;
}
if (Settings.GameSettings.jumpOnPress)
{
boostedJumpPower = (1 + (GetAngle() / 100));
}
currentMove.Jump(this, boostedJumpPower);
virtualController.Time_Hold_Button_A = 1f;
}
public void Run(int timeLimit)
{
int startTime = Environment.TickCount;
int iterationStartTime = 0;
int iterationTime = 0;
int maxIterationTime = 0;
int[] initialSolution = null;
double initialFitness = 0;
int[] currentSolution = null;
double currentFitness = 0;
int[] nextSolution = null;
double nextFitness = 0;
Tuple<int, int> nextTabu = null;
int[] neighbor = null;
double neighborFitness = 0;
LimitedQueue<Tuple<int,int>> tabuList = new LimitedQueue<Tuple<int, int>>(TabuListLength);
currentSolution = InitialSolution();
initialSolution = new int[currentSolution.Length];
currentSolution.CopyTo(initialSolution, 0);
currentFitness = Fitness(currentSolution);
BestFitness = currentFitness;
BestSolution = currentSolution;
while (Environment.TickCount - startTime < timeLimit - maxIterationTime) {
iterationStartTime = Environment.TickCount;
int count = 0;
nextSolution = null;
nextFitness = int.MaxValue;
nextTabu = null;
bool success = false;
// Finding the next movement.
Tuple<int, int> tabu = new Tuple<int, int>(-1, -1);
Tuple<int, int> lastTabu = new Tuple<int, int>(-1, -1);
while (count < NeighborChecks){
count ++;
neighbor = GetNeighbor(currentSolution);
tabu = GetTabu(currentSolution, neighbor);
if(!tabuList.Contains(tabu) && tabu != lastTabu) {
neighborFitness = Fitness(neighbor);
if (nextFitness > neighborFitness) {
nextSolution = neighbor;
nextFitness = neighborFitness;
nextTabu = tabu;
success = true;
}
if (currentFitness > nextFitness) {
break;
}
}
}
if (!success) {
nextSolution = initialSolution;
nextFitness = initialFitness;
}
// Aspiration.
if (BestFitness > nextFitness) {
tabuList.Clear();
BestSolution = nextSolution;
BestFitness = nextFitness;
}
tabuList.Enqueue(nextTabu);
currentSolution = nextSolution;
currentFitness = nextFitness;
iterationTime = Environment.TickCount - iterationStartTime;
maxIterationTime = (maxIterationTime < iterationTime) ? iterationTime : maxIterationTime;
}
}
public void LimitedQueue_SizeLimit()
{
LimitedQueue <SizedItem> queue = new LimitedQueue <SizedItem>(10);
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(0, queue.Size);
queue.SizeLimit = 10;
queue.Enqueue(new SizedItem(0, 3));
queue.Enqueue(new SizedItem(1, 3));
queue.Enqueue(new SizedItem(2, 3));
Assert.AreEqual(3, queue.Count);
Assert.AreEqual(9, queue.Size);
Assert.AreEqual(0, queue.Dequeue().Value);
Assert.AreEqual(6, queue.Size);
Assert.AreEqual(1, queue.Dequeue().Value);
Assert.AreEqual(3, queue.Size);
Assert.AreEqual(2, queue.Dequeue().Value);
Assert.AreEqual(0, queue.Size);
Assert.AreEqual(0, queue.Count);
queue.Enqueue(new SizedItem(0, 3));
queue.Enqueue(new SizedItem(1, 3));
queue.Enqueue(new SizedItem(2, 3));
queue.Enqueue(new SizedItem(3, 3));
Assert.AreEqual(3, queue.Count);
Assert.AreEqual(9, queue.Size);
Assert.AreEqual(1, queue.Dequeue().Value);
Assert.AreEqual(2, queue.Dequeue().Value);
Assert.AreEqual(3, queue.Dequeue().Value);
Assert.AreEqual(0, queue.Size);
Assert.AreEqual(0, queue.Count);
queue.Enqueue(new SizedItem(0, 10));
Assert.AreEqual(1, queue.Count);
Assert.AreEqual(0, queue.Dequeue().Value);
try
{
queue.Enqueue(new SizedItem(0, 11));
}
catch
{
// Expecting an exception
}
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(0, queue.Size);
queue.Enqueue(new SizedItem(0, 3));
queue.Enqueue(new SizedItem(0, 3));
Assert.AreEqual(6, queue.Size);
queue.Clear();
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(0, queue.Size);
queue.Enqueue(new SizedItem(0, 3));
queue.Enqueue(new SizedItem(1, 3));
queue.Enqueue(new SizedItem(2, 3));
Assert.AreEqual(9, queue.Size);
queue.SizeLimit = 7;
Assert.AreEqual(2, queue.Count);
Assert.AreEqual(6, queue.Size);
Assert.AreEqual(1, queue.Dequeue().Value);
Assert.AreEqual(2, queue.Dequeue().Value);
}
