protected override void OnEnabled() { base.OnEnabled(); ChatMessages = new LimitedQueue <Tuple <string, string, string> >(SettingsSystem.CurrentSettings.ChatBuffer); SetupRoutine(new RoutineDefinition(100, RoutineExecution.Update, ProcessReceivedMessages)); }
// 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; }
public void LimitedQueue_SizeAndCountLimit() { LimitedQueue <SizedItem> queue = new LimitedQueue <SizedItem>(); queue.CountLimit = 3; queue.SizeLimit = 10; queue.Enqueue(new SizedItem(0, 1)); queue.Enqueue(new SizedItem(1, 1)); queue.Enqueue(new SizedItem(2, 1)); queue.Enqueue(new SizedItem(3, 1)); Assert.AreEqual(3, queue.Count); Assert.AreEqual(3, queue.Size); Assert.AreEqual(1, queue.Dequeue().Value); Assert.AreEqual(2, queue.Dequeue().Value); Assert.AreEqual(3, queue.Dequeue().Value); Assert.AreEqual(0, queue.Count); Assert.AreEqual(0, queue.Size); queue.CountLimit = queue.CountLimit + 1; 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.Count); Assert.AreEqual(0, queue.Size); }
//public static Dictionary<string, FlushDetector> _flushers = new Dictionary<string, FlushDetector>(); private static LimitedQueue <ChatMessage> GetOrCreateRoomHistory(string id) { LimitedQueue <ChatMessage> h = null; if (!String.IsNullOrEmpty(id)) { id = id.ToLower(); if (_history.ContainsKey(id)) { h = _history[id]; } else { //Try get from cache if (CacheHandler.Instance.Exists(CacheKey(id))) { h = CacheHandler.Instance.Retrieve <LimitedQueue <ChatMessage> >(CacheKey(id)); } else { h = new LimitedQueue <ChatMessage>(100); } h.Limit = 100; _history.Add(id, h); } } return(h); }
public void LimitedQueue_Basic() { LimitedQueue <int> queue; try { queue = new LimitedQueue <int>(0); Assert.Fail("Expected ArgumentException"); } catch (Exception e) { Assert.IsInstanceOfType(e, typeof(ArgumentException)); } queue = new LimitedQueue <int>(5); queue.Enqueue(1); queue.Enqueue(2); queue.Enqueue(3); queue.Enqueue(4); queue.Enqueue(5); Assert.AreEqual(5, queue.Count); queue.Enqueue(6); Assert.AreEqual(5, queue.Count); for (int i = 0; i < 5; i++) { Assert.AreEqual(i + 2, queue.Dequeue()); } }
public void LimitedQueue_CountLimit() { LimitedQueue <PlainItem> queue = new LimitedQueue <PlainItem>(); queue.CountLimit = 3; queue.Enqueue(new PlainItem(0)); queue.Enqueue(new PlainItem(1)); queue.Enqueue(new PlainItem(2)); Assert.AreEqual(3, queue.Count); Assert.AreEqual(0, queue.Dequeue().Value); Assert.AreEqual(1, queue.Dequeue().Value); Assert.AreEqual(2, queue.Dequeue().Value); Assert.AreEqual(0, queue.Count); queue.Enqueue(new PlainItem(0)); queue.Enqueue(new PlainItem(1)); queue.Enqueue(new PlainItem(2)); queue.Enqueue(new PlainItem(3)); Assert.AreEqual(3, queue.Count); Assert.AreEqual(1, queue.Dequeue().Value); Assert.AreEqual(2, queue.Dequeue().Value); Assert.AreEqual(3, queue.Dequeue().Value); Assert.AreEqual(0, queue.Count); queue.Enqueue(new PlainItem(0)); queue.Enqueue(new PlainItem(1)); queue.Enqueue(new PlainItem(2)); queue.CountLimit = 2; Assert.AreEqual(2, queue.Count); Assert.AreEqual(1, queue.Dequeue().Value); Assert.AreEqual(2, queue.Dequeue().Value); }
private bool MonitorCast() { // Monitor the cast and break when either the player // moved or casting has been finished. var position = _fface.Player.Position; var castHistory = new LimitedQueue <short>(100); var prior = _fface.Player.CastPercentEx; while (!castHistory.RepeatsN(30).Any()) { if (prior == _fface.Player.CastPercentEx) { castHistory.AddItem(_fface.Player.CastPercentEx); } // Has moved if (position.X != _fface.Player.PosX || position.Y != _fface.Player.PosY || position.Z != _fface.Player.PosZ) { return(false); } prior = _fface.Player.CastPercentEx; Thread.Sleep(100); } // Report success if (castHistory.RepeatsN(30).Any(x => x.Equals(100))) { return(true); } return(false); }
/// <summary> /// Initializes a new instance of the <see cref="Taskstate"/> class. /// </summary> /// <param name="character">The character.</param> /// <param name="options">The options.</param> public Taskstate(Character character, Options options) { Character = character; Options = options; PreviousChestIndieces = new LimitedQueue <int>(3); _timer.Elapsed += Update; DominionSergeantIndex = -1; }
// Use this for initialization void Start() { text = GetComponentInChildren <Text> (); image = GetComponent <Image> (); panelColor = image.color; textColor = text.color; queue = new LimitedQueue <string> (SizeQueue); text.text = ""; }
public TuringNoveltyScorer(NoveltySearchParameters parameters) { _params = parameters; _archive = new LimitedQueue <Behaviour <TGenome> >(_params.ArchiveLimit); _pMin = _params.PMin; _generation = 0; _reportInterval = _params.ReportInterval; _knnTotalTimeSpent = 0; }
public static void TestEnqueue() { LimitedQueue <int> queue = new LimitedQueue <int>(3); queue.Add(1); queue.Add(2); queue.Add(3); Assert.AreEqual(queue.Count, 3); queue.Add(4); Assert.AreEqual(queue.Count, 3); }
public void LimitedQueueLimitA() { LimitedQueue<int> q = new LimitedQueue<int>(3); q.Enqueue(1); q.Enqueue(2); q.Enqueue(3); q.Enqueue(4); Assert.AreEqual(2, q.Dequeue()); }
public void TestEnqueue() { var queue = new LimitedQueue<int>(2); Assert.AreEqual(2, queue.Limit); queue.Enqueue(1); Assert.AreEqual(1, queue.Count); queue.Enqueue(2); Assert.AreEqual(2, queue.Count); queue.Enqueue(3); Assert.AreEqual(2, queue.Count); }
public void LimitedQueueLimitA() { LimitedQueue <int> q = new LimitedQueue <int>(3); q.Enqueue(1); q.Enqueue(2); q.Enqueue(3); q.Enqueue(4); Assert.AreEqual(2, q.Dequeue()); }
public void TestEnqueue() { var queue = new LimitedQueue <int>(2); Assert.AreEqual(2, queue.Limit); queue.Enqueue(1); Assert.AreEqual(1, queue.Count); queue.Enqueue(2); Assert.AreEqual(2, queue.Count); queue.Enqueue(3); Assert.AreEqual(2, queue.Count); }
public PlayarStatisistics(Guid id, PlayarName name) { Id = id; Name = name; Score = InitialScore; ScoreHistory = new LimitedQueue<Tuple<double, Activity>>(KeepLatestResults); Offensive = new GamePercentage(); Defensive = new GamePercentage(); Total = new GamePercentage(); _winning = new Streak(5); _loosing = new Streak(5); }
public PlayarStatisistics(Guid id, PlayarName name) { Id = id; Name = name; Score = InitialScore; ScoreHistory = new LimitedQueue <Tuple <double, Activity> >(KeepLatestResults); Offensive = new GamePercentage(); Defensive = new GamePercentage(); Total = new GamePercentage(); _winning = new Streak(5); _loosing = new Streak(5); }
public MachineAgent(Agent creator, string name, bool debug, DirectoryAgent directoryAgent, Machine machine, WorkTimeGenerator workTimeGenerator) : base(creator, name, debug) { _directoryAgent = directoryAgent; ProgressQueueSize = 1; // TODO COULD MOVE TO MODEL for CONFIGURATION, May not required anymore Queue = new List <WorkItem>(); // ThenBy( x => x.Status) ProcessingQueue = new LimitedQueue <WorkItem>(1); Machine = machine; WorkTimeGenerator = workTimeGenerator; ItemsInProgess = false; RegisterService(); QueueLength = 45; // plaing forecast }
public static List<string> ReadLastLines(string fileName, int linesCount = 10) { string line; var queue = new LimitedQueue<string>(linesCount); var shareMode = FileShare.ReadWrite | FileShare.Delete; using (var s = new FileStream(fileName, FileMode.Open, FileAccess.Read, shareMode)) using (var reader = new StreamReader(s)) { while ((line = reader.ReadLine()) != null) { queue.Enqueue(reader.ReadLine()); } } return queue.ToList(); }
public CustomMessageData(string Name, Action <byte[], Client> OnMessageReceived, bool ShouldStoreData, int QueueLimit = 1) { this.ShouldStoreData = ShouldStoreData; this.Name = Name; this.OnMessageReceived = OnMessageReceived; if (ShouldStoreData) { StoredData = new LimitedQueue <byte[]>(QueueLimit); } else { StoredData = null; } }
public MapleClient(Socket session) { SClient = new CClientSocket(this, session); Host = SClient.Host; Port = SClient.Port; ServerConsole.Info(String.Format("{0}:{1} Connnected", Host, Port)); Channel = 1; Connected = true; LastPacketsSent = new LimitedQueue <PacketWriter>(10); CheatTracker = new OffenceTracker() { Client = this }; }
/// <summary> /// Add an item(s) to the LZ77 queue /// </summary> /// <typeparam name="T">Type of the data being addeded</typeparam> /// <param name="data">Data to take the data from</param> /// <param name="queue">Queue of data to add to</param> /// <param name="startPosition">Position to start adding from</param> /// <param name="count">Count of items to copy</param> /// <returns>Ending position</returns> private static int AddQueueItems <T>(ref T[] data, ref LimitedQueue <T> queue, int startPosition, int count) { // Create a copy of the start position var endPosition = startPosition; // Iterate over it, adding the data items required for (var i = 0; i < count; i++, endPosition++) { queue.Enqueue(data[startPosition + i]); } // Return the end position return(endPosition); }
//public Surface[][] SurfacePrediction = new Surface[Settings.PredictionLength][]; public TankPlus(long id) { Id = id; for (int i = 0; i < Settings.BufferSize; ++i) { AngleHistory[i] = new LimitedQueue<double>(Settings.BufferSize - i, 0); SpeedHistory[i] = new LimitedQueue<double>(Settings.BufferSize - i, 0); OrientationHistory[i] = new LimitedQueue<double>(Settings.BufferSize - i, 0); } //for (int i = 0; i < Settings.PredictionLength; ++i) // SurfacePrediction[i] = new Surface[4]; }
public static void Add(ChatMessage message) { LimitedQueue <ChatMessage> h = GetOrCreateRoomHistory(message.RoomID); if (h != null) { message.CreationDate = Data.Repository.CurrentDate; h.Add(message); Task.Run(() => { CacheHandler.Instance.Replace <LimitedQueue <ChatMessage> >(CacheKey(message.RoomID), h, null); }); } }
public void AddingItemsBehindLimitRemovesFirstIn() { LimitedQueue <int> q = new LimitedQueue <int>(3); Assert.AreEqual(0, q.Count); q.Enqueue(1); Assert.AreEqual(1, q.Count); q.Enqueue(2); Assert.AreEqual(2, q.Count); q.Enqueue(3); Assert.AreEqual(3, q.Count); q.Enqueue(4); Assert.AreEqual(3, q.Count); Assert.IsFalse(q.Contains(1)); }
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 void LimitedQueueLimitB() { LimitedQueue<int> q = new LimitedQueue<int>(10); q.Enqueue(1); q.Enqueue(2); q.Enqueue(3); q.Enqueue(4); q.Enqueue(5); q.Enqueue(6); q.Enqueue(7); q.Limit = 2; Assert.AreEqual(6, q.Dequeue()); }
public USocket(uint id) { this.id = id; netState = NetState.None; sequence = 0; ack = 0; ackbit = 0; quantics = new Dictionary <byte, Packet>(); cacheSend = new List <Packet>(); cacheReceived = new List <Packet>(); cacheLost = new List <byte>(); lastConnectTime = lastReceviedTime = DateTime.MinValue; connectTimes = 0; sends = new LimitedQueue <Packet>(10); receives = new LimitedQueue <Packet>(10); }
public void LimitedQueueLimitB() { LimitedQueue <int> q = new LimitedQueue <int>(10); q.Enqueue(1); q.Enqueue(2); q.Enqueue(3); q.Enqueue(4); q.Enqueue(5); q.Enqueue(6); q.Enqueue(7); q.Limit = 2; Assert.AreEqual(6, q.Dequeue()); }
static void Main() { var queue = new LimitedQueue<int>(3); for (var i = 0; i < Environment.ProcessorCount; i++) { var worker = new WorkingThread(i, queue); ThreadPool.QueueUserWorkItem(_ => { worker.DoWork(); }); } Console.ReadLine(); }
public void LimitedQueue_Dispose() { LimitedQueue <Test> queue; Test item1 = new Test(1); Test item2 = new Test(2); Test item3 = new Test(3); queue = new LimitedQueue <Test>(2); queue.Enqueue(item1); queue.Enqueue(item2); queue.Enqueue(item3); Assert.AreEqual(2, queue.Count); Assert.IsTrue(item1.Disposed); Assert.IsFalse(item2.Disposed); Assert.IsFalse(item2.Disposed); }
private string ToMultiLineString(LimitedQueue <LogModel> logMessages) { var result = new StringBuilder(); var copy = logMessages.ToList(); foreach (var logMessage in copy) { if (logMessage == null) { continue; } result.Append($"{logMessage.LogLevel} {logMessage.Message}{Environment.NewLine}"); } return(result.ToString()); }
public MovementClass1(string s) { base.name = s; this.setTreshold(.2d, 0.5d); myQueue = new LimitedQueue <GMVector>(_queueLength); myAverages = new LimitedQueue <gRMSAverage>(_queueLength); //need at least 3 seconds recording size, but only record crossing values myCrossUPs = new LimitedQueue <gRMSAverage>(_queueLength); myCrossDOWNs = new LimitedQueue <gRMSAverage>(_queueLength); myGmin = 0.2d; //was 0.9d but we get a deltaAverage of about around 0.14 myTmin = 10; // 15 is equal to 0.75 seconds if samples per seconds is 20 _treshCountRMS = 2000; //should be 3000 for 60 samples in 3 seconds at 20 samples/second, //BUT we only see ~2 samples per second basicLogger("Movement1 Class\r\nx\ty\tz\ttick\tdeltaG"); }
public MovementClass1(string s) { base.name = s; this.setTreshold(.2d, 0.5d); myQueue = new LimitedQueue<GMVector>(_queueLength); myAverages = new LimitedQueue<gRMSAverage>(_queueLength); //need at least 3 seconds recording size, but only record crossing values myCrossUPs = new LimitedQueue<gRMSAverage>(_queueLength); myCrossDOWNs = new LimitedQueue<gRMSAverage>(_queueLength); myGmin = 0.2d; //was 0.9d but we get a deltaAverage of about around 0.14 myTmin = 10; // 15 is equal to 0.75 seconds if samples per seconds is 20 _treshCountRMS = 2000; //should be 3000 for 60 samples in 3 seconds at 20 samples/second, //BUT we only see ~2 samples per second basicLogger("Movement1 Class\r\nx\ty\tz\ttick\tdeltaG"); }
private void Awake() { groundQueue = new LimitedQueue <bool>(groundedBufferSize); virtualController = GetComponent <VirtualController>(); currentMove = idleMove; idleMove.EnterState(this); accelRatePerSec = maxSpeed / timeZeroToMax; decelRatePerSec = -maxSpeed / timeMaxToZero; timeToJumpApex = jumpHeight / 10; gravity = -(2 * jumpHeight) / Mathf.Pow(timeToJumpApex, 2); minimumJumpVelocity = Mathf.Abs(gravity) * timeToJumpApex; normalGravity = gravity; jumpSlider.maxValue = maxJumpBoost; audioObj = GameObject.FindGameObjectWithTag("audio"); }
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_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); }
private void Awake() { inputQueue = new LimitedQueue <bool>(inputQueueSize); }
public void ManageInventory() { bool runInventory = true; //Queue commands = new Queue(); LimitedQueue<string> messageBoard = new LimitedQueue<string>(15); List<string> commands = new List<string>(); while (runInventory) { Console.Clear(); Console.Write(this.ToString()); Console.WriteLine(); Console.WriteLine("To strip item, write 'strip #of_equipment'\n" + "To equip item, wrire 'equip #of_equipment'\n" + "To drop item from inventory, write 'drop #of_equipment'\n" + "To use the item, write 'use #of_equipment'\n" + "To go back to game, press Escape\n"); foreach (string s in messageBoard) { Console.WriteLine(s); } string response = commands.ListThroughCommands(); commands.Add(response); messageBoard.Enqueue(response); string[] words = response.Split(' '); int n; switch (words[0]) { case "close": { runInventory = false; break; } case "strip": { try { n = int.Parse(words[1]); messageBoard.Enqueue(this.StripItem(this.equiped.bag[n-1])); } catch { messageBoard.Enqueue("Something wrong with your output"); } break; } case "equip": { try { n = int.Parse(words[1]); messageBoard.Enqueue(this.EquipItem(this.bag.bag[n-1], true)); } catch { messageBoard.Enqueue("Something wrong with your output"); } break; } case "drop": { try { n = int.Parse(words[1]); Location loc = ThisGame.dungeon.location[this.X,this.Y]; if (loc.CanDropItemOnto()) { Item i = this.bag.bag[n-1]; messageBoard.Enqueue(this.DropItem(i)); ThisGame.dungeon.location[this.X,this.Y].DropItemOnLocation(i); ThisGame.dungeon.location[this.X,this.Y].UpdateSymbol(); } } catch { messageBoard.Enqueue("Something wrong with your output"); } break; } case "use": { try { n = int.Parse(words[1]); Item i = this.bag.bag[n-1]; messageBoard.Enqueue(i.Use()); } catch { messageBoard.Enqueue("Something wrong with your output"); } break; } default: { messageBoard.Enqueue("Can not recognize the command"); break; } } } }
public override void VoluntaryAction(Player p) { bool lootChest = true; LimitedQueue<string> messageBoard = new LimitedQueue<string>(10); List<string> commands = new List<string>(); while (lootChest) { Console.Clear(); Console.WriteLine(this.message); Console.Write(this.Content.ToString()); Console.WriteLine(); Console.WriteLine("YOUR INVENTORY"); Console.Write(p.bag.ToString()); Console.WriteLine(); Console.WriteLine("To pick item, write 'pick #of_equipment' or write 'pick all' to take everything\n" + "To drop item from inventory, write 'drop #of_equipment'\n" + "To go back to game, press Escape\n"); foreach (string s in messageBoard) { Console.WriteLine(s); } string response = commands.ListThroughCommands(); commands.Add(response); messageBoard.Enqueue(response); string[] words = response.Split(' '); int n; switch (words[0]) { case "close": { lootChest = false; break; } case "pick": { try { if (words[1] == "all") { if (p.bag.maxsize - p.bag.Count() - this.Content.Count() < 0) { messageBoard.Enqueue("You don't have enough space to take all items in your bag."); break; } foreach (Item i in this.Content.bag) { p.PickItem(i); } this.Content.RemoveAll(); messageBoard.Enqueue("All items has been taken"); } else { n = int.Parse(words[1]); if (p.bag.maxsize - p.bag.Count() > 0) { p.PickItem(this.Content.bag[n-1]); messageBoard.Enqueue(this.Content.bag[n-1].Name); this.Content.Remove(this.Content.bag[n-1]); } else messageBoard.Enqueue("You don't have enough space to take all items in your bag."); } } catch { messageBoard.Enqueue("Something wrong with your command"); } break; } case "drop": { try { n = int.Parse(words[1]); this.Content.Add(p.bag.GetItem(p.bag.bag[n-1].Name)); messageBoard.Enqueue(p.bag.bag[n-1].Name); p.DropItem(p.bag.bag[n-1]); } catch { messageBoard.Enqueue("Something wrong with your command"); } break; } default: { messageBoard.Enqueue("Can not recognize the command"); break; } } } }
public MemoryStorage(int capacity) { _queue = new LimitedQueue<SyslogMessage>(capacity); }
private void UpdateComponents(ref LimitedQueue<double>[] history, ref double[] valuePrediction) { for (int i = 1; i < Settings.BufferSize; ++i) history[i].Enqueue(history[i - 1].Last - history[i - 1].Penultimate); double[] tmpValues = new double[Settings.BufferSize]; int tmpBufferSizeMinusOne = Settings.BufferSize - 1; for (int i = 0; i < tmpBufferSizeMinusOne; ++i) { double tmpSum = 0; foreach (double tmpValue in history[i]) tmpSum += tmpValue; tmpValues[i] = tmpSum / history[i].Limit; } tmpValues[tmpBufferSizeMinusOne] = 0; for (int i = 0; i < Settings.PredictionLength; ++i) { valuePrediction[i] = tmpValues[0]; for (int j = tmpBufferSizeMinusOne; j > 0; --j) tmpValues[j - 1] += tmpValues[j]; } }
public void Uninitialize() { queue = null; }
private bool MonitorCast() { // Monitor the cast and break when either the player // moved or casting has been finished. var position = _fface.Player.Position; var castHistory = new LimitedQueue<short>(100); var prior = _fface.Player.CastPercentEx; while (!castHistory.RepeatsN(30).Any()) { if (prior == _fface.Player.CastPercentEx) castHistory.AddItem(_fface.Player.CastPercentEx); // Has moved if (position.X != _fface.Player.PosX || position.Y != _fface.Player.PosY || position.Z != _fface.Player.PosZ) return false; prior = _fface.Player.CastPercentEx; Thread.Sleep(100); } // Report success if (castHistory.RepeatsN(30).Any(x => x.Equals(100))) return true; return false; }
public SemaphoreGesture() { _history = new LimitedQueue<Semaphore>(_historyCount); }
public WorkingThread(int id, LimitedQueue<int> queue) { ThreadId = id; _queue = queue; }
public void LimitedQueueLimitC() { LimitedQueue<string> q = new LimitedQueue<string>(10); Assert.AreEqual(10, q.Limit); }
public void Initialize() { queue = new LimitedQueue<FileSystemInfo> (); ScanDirectory (directory); }
public ClapGesture() { _history = new LimitedQueue<Hands>(PointCount); }
public PrintingCalculator() { RunningCalculations = new LimitedQueue<string>(); RunningCalculations.Limit = 20; RunningTotal = 0; }
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 TraceListener() { this.StringQueue = new LimitedQueue<string>(MAX_CACHED_MESSAGES); }