public void Move() { GameObject snakeHead = snakeBody.RemoveBack(); Vector3 oldSnakeHeadVector = snakeHead.transform.position; oldSnakeHeadX = oldSnakeHeadVector.x; oldSnakeHeadY = oldSnakeHeadVector.y; // update Snakehead to new coordinates var newSnakeHeadX = oldSnakeHeadX + snakeStepMapping[snakeHeadDirection][0]; var newSnakeHeadY = oldSnakeHeadY + snakeStepMapping[snakeHeadDirection][1]; Vector3 newSnakeHeadVector = new Vector3(newSnakeHeadX, newSnakeHeadY); // put prepareToSpawnSnakeBodyPart() after setting position of new snake head // otherwise foodEaten cannot be set to true through collision event before snake body part is spawned snakeHead.transform.position = newSnakeHeadVector; spawnerController.AddEmptyCell(oldSnakeHeadVector); spawnerController.RemoveEmptyCell(newSnakeHeadVector); PrepareToSpawnSnakeBodyPart(); snakeBody.AddBack(snakeHead); // TODO check if snake ate first RemoveSnakeTail(); SetFoodEaten(false); }
public void EnqueueDeferred(IEntity source, QueueAction a) { if (a == null) { return; } #if _QUEUE_DEBUG DebugLog.WriteLine("Queue (Game " + Game.GameId + "): Queueing action " + a + " for " + source.ShortDescription + " at depth " + Depth); #endif var e = initializeAction(source, a); if (OnQueueing != null) { OnQueueing(this, e); // TODO: Count the number of arguments the cancelled action would take and remove those too if (!e.Cancel) { Queue.AddBack(e); } } else { Queue.AddBack(e); } OnQueued?.Invoke(this, e); }
public void AddAlly(DeferredFollower ally) { if (ally != null) { m_allies.AddBack(ally); UpdateOffsets(); } }
public void TestAddBack() { Deque <int> deque = new Deque <int>(); deque.AddBack(1); deque.RemoveFront(); deque.AddBack(1); Assert.AreEqual(1, deque.RemoveFront()); }
public void AddBackTest() { var deque = new Deque <object>(); deque.AddBack(1); deque.AddBack(2); Assert.AreEqual(1, deque[0]); Assert.AreEqual(2, deque[1]); }
void Update() { for (int audioSourceIndex = 0; audioSourceIndex < activatedInstances.Count; ++audioSourceIndex) { AudioSource audioSource = activatedInstances[audioSourceIndex]; if (!audioSource.isPlaying) { audioSource.Stop(); activatedInstances.RemoveAt(audioSourceIndex); audioSource.volume = 0f; audioSource.clip = null; audioSource.outputAudioMixerGroup = null; audioSource.transform.position = Vector3.zero; audioSource.transform.rotation = Quaternion.identity; audioSource.gameObject.SetActive(false); pool.AddBack(audioSource); } } }
private static long SolveB(IEnumerable <string> data, int preambleLength = 25, int combinationSize = 2) { var dataStrings = data.ToArray(); var array = Text.StringsToLongs(dataStrings).ToArray(); var numbers = new Span <long>(array); var expectedSum = SolveA(dataStrings, preambleLength, combinationSize); var d = new Deque <long>(); var i = 0; while (i < numbers.Length) { var sum = d.Sum(); if (sum < expectedSum) { d.AddBack(numbers[i++]); } else if (sum > expectedSum) { d.PopFront(); } else { break; } } return(d.Min() + d.Max()); }
internal Context(List <Func <ComponentInfo> > componentCtors, int initialCapacity, int maxCapacity) { OnClear = delegate { }; OnGrow = delegate { }; OnInit = delegate { }; OnRemove = delegate { }; _componentsInfo = componentCtors.Select(c => c()).ToArray(); _capacity = initialCapacity; _maxCapacity = maxCapacity; _freeList = new Deque <int>(_capacity); _generations = new ushort[_capacity]; for (var i = _capacity - 1; i >= 0; i--) { _freeList.AddBack(i); } // Initialize scopes OnInit(_capacity); _count = 0; Instance = this; }
public void DestroyEntity(Entity <TScope> entity) { #if !UNSAFE_ECS EnsureEntityExists(entity); #endif OnRemove(entity); var index = entity.Index; _generations[index]++; if (_generations[index] == 0) { _generations[index]++; // handle overflow } _freeList.AddBack(index); _count--; }
public void AddNullTest() { var deque = new Deque <object>(); deque.AddBack(null); Assert.IsNull(deque.RemoveBack()); }
public void add(T item) { if (UndoDeque.Count > BufferSize) { UndoDeque.RemoveFront(); } UndoDeque.AddBack(item); if (UndoDeque.Count > 1) { CanUndo = true; } if (RedoDeque.Count > 0) { RedoDeque.RemoveRange(0, RedoDeque.Count); CanRedo = false; } }
public void CountTest() { var deque = new Deque <object>(); deque.AddBack(1); Assert.AreEqual(1, deque.Count); deque.AddFront(2); Assert.AreEqual(2, deque.Count); }
public void TestAddVariants() { for (int i = 0; i < Math.Pow(2, 4); i++) { Deque <int> deque = new Deque <int>(); if (back(i, 0)) { deque.AddBack(1); } else { deque.AddFront(1); } if (back(i, 1)) { deque.RemoveBack(); } else { deque.RemoveFront(); } if (back(i, 2)) { deque.AddBack(2); } else { deque.AddFront(2); } int item; if (back(i, 3)) { item = deque.RemoveBack(); } else { item = deque.RemoveFront(); } Assert.AreEqual(2, item); } }
static void Main() { Deque <int> deque = new Deque <int>(); deque.AddFront(6); deque.AddBack(5); deque.AddBack(7); deque.AddBack(8); Console.WriteLine(deque.Count); // 4 Console.WriteLine(deque.Capacity); // 16 deque.RemoveAt(8); Console.WriteLine(deque.Count); // 3 deque.RemoveAt(7); Console.WriteLine(deque.Count); // 2 deque.InsertAt(10, 9); Console.WriteLine(deque[10]); // 9 Console.WriteLine(deque.Count); // 3 deque.Clear(); for (int i = 0; i < 20; i++) { deque.AddBack(i); } Console.WriteLine(deque.Capacity); // 32 Console.WriteLine(deque.Count); // 20 deque.Clear(); Console.WriteLine(deque.Count); // 0 Console.WriteLine(deque.Capacity); // 16 Console.WriteLine(deque[7]); // 0 deque[5] = 123; Console.WriteLine(deque[5]); // 123 }
static void Main() { Deque <int> deque = new Deque <int>(40); deque.AddFront(10); deque.AddBack(50); // 10 50 Deque <int> anotherDeque = new Deque <int>(); anotherDeque.AddFront(5); anotherDeque.AddFront(10); // 10 5 Deque <int> result = deque + anotherDeque; // 10 50 10 5 }
public T undo() { if (UndoDeque.Count > 1) { T item = UndoDeque.RemoveBack(); RedoDeque.AddBack(item); if (UndoDeque.Count == 1) { CanUndo = false; } CanRedo = true; return(UndoDeque.Get(UndoDeque.Count - 1)); } if (UndoDeque.Count == 1) { CanUndo = false; } return(default(T)); }
/// <summary> /// A function to set the booleans for beats by comparing current audio sample with statistical values of previous one's /// </summary> /// <param name="spectrum">reference to the array containing current samples and amplitudes</param> /// <param name="avgSpectrum">reference to the array containing average values for the sample amplitudes</param> /// <param name="isBass">bool to check if current value is higher than average for bass frequencies</param> /// <param name="isLow">bool to check if current value is higher than average for low-mid frequencies</param> void GetBeat(ref float[] spectrum, ref float[] avgSpectrum, ref bool isBass, ref bool isLow) { int numBands = 2; //beatDetector_bandLimits.size() / 2 int numChannels = audioSource.clip.channels; for (int numBand = 0; numBand < numBands; ++numBand) { for (int indexFFT = beatDetector_bandLimits[numBand]; indexFFT < beatDetector_bandLimits[numBand + 1]; ++indexFFT) { for (int channel = 0; channel < numChannels; ++channel) { float[] tempSample = new float[1024]; audioSource.GetSpectrumData(tempSample, channel, FFTWindow.Rectangular); spectrum[numBand] += tempSample[indexFFT]; } } spectrum[numBand] /= (beatDetector_bandLimits[numBand + 1] - beatDetector_bandLimits[numBand] * numBand); } if (FFTHistory_beatDetector.Count > 0) { FillAvgSpectrum(ref avgSpectrum, numBands, ref FFTHistory_beatDetector); float[] varianceSpectrum = new float[numBands]; FillVarianceSpectrum(ref varianceSpectrum, numBands, ref FFTHistory_beatDetector, ref avgSpectrum); isBass = (spectrum[0] - 0.05) > BeatThreshold(varianceSpectrum[0]) * avgSpectrum[0]; isLow = (spectrum[1] - 0.005) > BeatThreshold(varianceSpectrum[1]) * avgSpectrum[1]; } List <float> fftResult = new List <float>(numBands); for (int index = 0; index < numBands; ++index) { fftResult.Add(spectrum[index]); } if (FFTHistory_beatDetector.Count >= FFTHistory_maxSize) { FFTHistory_beatDetector.RemoveFront(); } FFTHistory_beatDetector.AddBack(fftResult); }
public void Push(VEntity e) { gameplayEventQueue.AddBack(e); }
public void TestAdd() { Deque <int> deque = new Deque <int>(); Assert.IsTrue(deque.IsEmpty); int item = 1; Assert.IsFalse(deque.Contains(item)); deque.Add(item); int actualBack; actualBack = deque[0]; Assert.IsTrue(deque.Contains(item)); Assert.AreEqual(item, actualBack); int itemNewBack = 2; Assert.IsFalse(deque.Contains(itemNewBack)); deque.AddBack(itemNewBack); Assert.IsTrue(deque.Contains(itemNewBack)); actualBack = deque[1]; Assert.AreEqual(itemNewBack, actualBack); actualBack = deque.RemoveBack(); Assert.AreEqual(itemNewBack, actualBack); int itemNewFront = -1; Assert.IsFalse(deque.Contains(itemNewFront)); deque.AddFront(itemNewFront); int actualFront; Assert.IsTrue(deque.Contains(itemNewFront)); actualFront = deque[0]; Assert.AreEqual(itemNewFront, actualFront); actualFront = deque.RemoveFront(); Assert.AreEqual(itemNewFront, actualFront); int[] itemRange = new[] { 3, 4, 5, 6 }; int offset = deque.Count; deque.AddRange(itemRange); foreach (var itm in itemRange) { Assert.AreEqual(itm, deque[offset]); offset++; } int[] itemBackRange = new[] { 7, 8, 9, 10 }; offset = deque.Count; deque.AddBackRange(itemBackRange); foreach (var itm in itemBackRange) { Assert.AreEqual(itm, deque[offset]); offset++; } int[] itemFrontRange = new[] { 3, 4, 5, 6 }; deque.AddFrontRange(itemFrontRange); for (int i = 0; i < itemFrontRange.Length; i++) { var itm = itemFrontRange[i]; Assert.AreEqual(itm, deque[i]); } }
public void TestAddBack() { Deque<int> deque = new Deque<int>(); deque.AddBack(1); deque.RemoveFront(); deque.AddBack(1); Assert.AreEqual(1, deque.RemoveFront()); }
/// <summary> /// Checks the Inputs for a Skill /// </summary> public void Update() { if (m_skills.Count > 0) { if (Input.GetButtonDown(CYCLE_FWD_BTN)) { m_skills.AddBack(m_skills.RemoveFront()); if (m_orbiter != null) { m_orbiter.CycleForward(); } } else if (Input.GetButtonDown(CYCLE_BCK_BTN)) { m_skills.AddFront(m_skills.RemoveBack()); if (m_orbiter != null) { m_orbiter.CycleBackward(); } } if (Input.GetButtonDown(DROP_BTN)) { if (m_skills.Get(0).Ally != DefaultAlly) { DeferredFollower allyFollower = m_orbiter.ActiveAlly; Ally pickup = allyFollower.gameObject.GetComponentInChildren <Ally>(); // Enables the pickup collider pickup.Drop(); // Find the closest available point between the Player and the Crosshair to place the // dropped Ally NavMeshHit hit; allyFollower.ForcePathfinding(); if (NavMesh.SamplePosition(m_aim.Target, out hit, MAX_DROP_RADIUS, NavMesh.AllAreas)) { allyFollower.Target = hit.position; } else { allyFollower.Target = m_aim.Target; } // Remove ally m_orbiter.RemoveFront(); // Remove ally's skillset m_skills.RemoveFront(); } } if (Input.GetButtonDown(PICKUP_BTN) && m_collidedAllies.Count > 0) { m_collidedAllies.Sort(DistanceSort); AddAlly(m_collidedAllies[0]); } } RunSkill(PRIMARY_FIRE_BTN, m_skills.Get(0).AttackSkill); RunSkill(DASH_BTN, m_skills.Get(0).DashSkill); }
public void Add(VEntity e) { animationEventsQueue.AddBack(e); }
public void Add(T item) { deque.AddBack(item); }
public void TestAddVariants() { for (int i = 0; i < Math.Pow(2, 4); i++) { Deque<int> deque = new Deque<int>(); if (back(i, 0)) { deque.AddBack(1); } else { deque.AddFront(1); } if (back(i, 1)) { deque.RemoveBack(); } else { deque.RemoveFront(); } if (back(i, 2)) { deque.AddBack(2); } else { deque.AddFront(2); } int item; if (back(i, 3)) { item = deque.RemoveBack(); } else { item = deque.RemoveFront(); } Assert.AreEqual(2, item); } }
public void TestAdd() { Deque<int> deque = new Deque<int>(); Assert.IsTrue(deque.IsEmpty); int item = 1; Assert.IsFalse(deque.Contains(item)); deque.Add(item); int actualBack; actualBack = deque[0]; Assert.IsTrue(deque.Contains(item)); Assert.AreEqual(item, actualBack); int itemNewBack = 2; Assert.IsFalse(deque.Contains(itemNewBack)); deque.AddBack(itemNewBack); Assert.IsTrue(deque.Contains(itemNewBack)); actualBack = deque[1]; Assert.AreEqual(itemNewBack, actualBack); actualBack = deque.RemoveBack(); Assert.AreEqual(itemNewBack, actualBack); int itemNewFront = -1; Assert.IsFalse(deque.Contains(itemNewFront)); deque.AddFront(itemNewFront); int actualFront; Assert.IsTrue(deque.Contains(itemNewFront)); actualFront = deque[0]; Assert.AreEqual(itemNewFront, actualFront); actualFront = deque.RemoveFront(); Assert.AreEqual(itemNewFront, actualFront); int[] itemRange = new[] { 3, 4, 5, 6 }; int offset = deque.Count; deque.AddRange(itemRange); foreach (var itm in itemRange) { Assert.AreEqual(itm, deque[offset]); offset++; } int[] itemBackRange = new[] { 7, 8, 9, 10 }; offset = deque.Count; deque.AddBackRange(itemBackRange); foreach (var itm in itemBackRange) { Assert.AreEqual(itm, deque[offset]); offset++; } int[] itemFrontRange = new[] { 3, 4, 5, 6 }; deque.AddFrontRange(itemFrontRange); for (int i = 0; i < itemFrontRange.Length; i++) { var itm = itemFrontRange[i]; Assert.AreEqual(itm, deque[i]); } }
//void ResetTurnQueue() //{ // PlayerTurn plyTurn = new PlayerTurn("Player"); // EnemyTurn emTurn1 = new EnemyTurn("Orange box"); // EnemyTurn emTurn2 = new EnemyTurn("Blue box"); // EnemyTurn emTurn3 = new EnemyTurn("Purple box"); // turnQueue.Enqueue(plyTurn); // turnQueue.Enqueue(emTurn1); // turnQueue.Enqueue(emTurn2); // turnQueue.Enqueue(emTurn3); //} public void EnqueueTurn(ref IState<TurnManager> _state) { turnDequeue.AddBack(_state); }
// Render pipeline callbacks void OnPreCull() { int width = m_Camera.pixelWidth; int height = m_Camera.pixelHeight; m_RenderTexture = RenderTexture.GetTemporary(width, height, 16, RenderTextureFormat.Default); m_OutlineCamera.targetTexture = m_RenderTexture; // Save current Renderer Materials into m_MaterialsCache and overwrite them with buffer Materials. for (int rendererIndex = 0; rendererIndex < m_OutlinedRenderers.Count; ++rendererIndex) // RENDERERS { Renderer currentRenderer = m_OutlinedRenderers[rendererIndex]; if (currentRenderer != null) { // Get a copy of the current materials list. Material[] materials = currentRenderer.sharedMaterials; for (int materialIndex = 0; materialIndex < materials.Length; ++materialIndex) { Material currentMaterial = materials[materialIndex]; Texture currentTexture = currentMaterial.mainTexture; m_MaterialsCache.AddBack(currentMaterial); // Save current Material into the cache. Material newMaterial = m_OutlinedBufferMaterialsPool.RemoveFront(); // Take an unused material from the pool. if (newMaterial == null) { newMaterial = CreateMaterial(new Color(1f, 0f, 0f, 0f)); // Fallback case. You should never enter here and do runtime allocations. Debug.LogWarning("[OutlineCamera] Material instance created during runtime. Check current pool size."); } newMaterial.mainTexture = currentTexture; // Set texture from current material. materials[materialIndex] = newMaterial; } // Overwrite materials (temporary). currentRenderer.sharedMaterials = materials; m_LayersCache.AddBack(currentRenderer.gameObject.layer); // Save current layer into the cache. currentRenderer.gameObject.layer = LayerMask.NameToLayer("Outline"); // Overwrite layer (temporary). } } for (int rendererIndex = 0; rendererIndex < m_EraserRenderers.Count; ++rendererIndex) // ERASERS { Renderer currentRenderer = m_EraserRenderers[rendererIndex]; if (currentRenderer != null) { // Get a copy of the current materials list. Material[] materials = currentRenderer.sharedMaterials; for (int materialIndex = 0; materialIndex < materials.Length; ++materialIndex) { Material currentMaterial = materials[materialIndex]; Texture currentTexture = currentMaterial.mainTexture; m_MaterialsCache.AddBack(currentMaterial); // Save current Material into the cache. Material newMaterial = m_EraserBufferMaterialsPool.RemoveFront(); // Take an unused material from the pool. if (newMaterial == null) { newMaterial = CreateMaterial(new Color(0f, 0f, 0f, 0f)); // Fallback case. You should never enter here and do runtime allocations. Debug.LogWarning("[OutlineCamera] Material instance created during runtime. Check current pool size."); } newMaterial.mainTexture = currentTexture; // Set texture from current material. materials[materialIndex] = newMaterial; } // Overwrite materials (temporary). currentRenderer.sharedMaterials = materials; m_LayersCache.AddBack(currentRenderer.gameObject.layer); // Save current layer into the cache. currentRenderer.gameObject.layer = LayerMask.NameToLayer("Outline"); // Overwrite layer (temporary). } } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Render to texture. m_OutlineCamera.Render(); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// for (int rendererIndex = 0; rendererIndex < m_OutlinedRenderers.Count; ++rendererIndex) { Renderer currentRenderer = m_OutlinedRenderers[rendererIndex]; if (currentRenderer != null) { Material[] materials = currentRenderer.sharedMaterials; for (int materialIndex = 0; materialIndex < materials.Length; ++materialIndex) { Material tempMaterial = materials[materialIndex]; tempMaterial.SetTexture(0, null); // Release temporary assigned texture. m_OutlinedBufferMaterialsPool.AddBack(tempMaterial); // Re-insert into pool. Material originalMaterial = m_MaterialsCache.RemoveFront(); materials[materialIndex] = originalMaterial; // Restore original Renderer Material. } currentRenderer.sharedMaterials = materials; int originalLayer = m_LayersCache.RemoveFront(); currentRenderer.gameObject.layer = originalLayer; // Overwrite layer (temporary). } } for (int rendererIndex = 0; rendererIndex < m_EraserRenderers.Count; ++rendererIndex) { Renderer currentRenderer = m_EraserRenderers[rendererIndex]; if (currentRenderer != null) { Material[] materials = currentRenderer.sharedMaterials; for (int materialIndex = 0; materialIndex < materials.Length; ++materialIndex) { Material tempMaterial = materials[materialIndex]; tempMaterial.SetTexture(0, null); // Release temporary assigned texture. m_EraserBufferMaterialsPool.AddBack(tempMaterial); // Re-insert into pool. Material originalMaterial = m_MaterialsCache.RemoveFront(); materials[materialIndex] = originalMaterial; // Restore original Renderer Material. } currentRenderer.sharedMaterials = materials; int originalLayer = m_LayersCache.RemoveFront(); currentRenderer.gameObject.layer = originalLayer; // Overwrite layer (temporary). } } }