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).
}
}
}