static void Main()
{
Deque<int> deque = new Deque<int>();
Deque<object> dequeOfObjects = new Deque<object>();
//dequeOfIntegers.AddFront(5);
//dequeOfIntegers.AddBack(10);
//int frontRemoved = dequeOfIntegers.RemoveFront();
//int backRemoced = dequeOfIntegers.RemoveBack();
//int frontPeek = dequeOfIntegers.PeekFront();
//int backPeek = dequeOfIntegers.PeekBack();
//int elements = dequeOfIntegers.Count;
//int maxCapacity = dequeOfIntegers.Capacity;
deque.AddFront(10);
deque.AddFront(50);
System.Console.WriteLine(deque.Count);
deque[0] = 500;
System.Console.WriteLine(deque[0]);
Deque<int> anotherDeque = new Deque<int>();
anotherDeque.AddFront(5);
anotherDeque.AddFront(10);
Deque<int> result = deque + anotherDeque;
}
public void Undo()
{
// if we can't modify the buffer...
if (!byteBuffer.ModifyAllowed)
{
return;
}
// undo buffer changes
byteBuffer.Undo();
// restore cursor position
if (cursorUndoDeque.Count > 0)
{
CursorState ch = (CursorState)cursorUndoDeque.RemoveFront();
cursorRedoDeque.AddFront(ch);
// clear the selection
this.SetSelection(-1, -1);
dvDisplay.MakeOffsetVisible(ch.UndoOffset, DataViewDisplay.ShowType.Closest);
this.MoveCursor(ch.UndoOffset, ch.UndoDigit);
}
}
public void AddFrontItems()
{
deq.AddFront(1);
Assert.Equal(1, deq.GetLength());
}
public void AddTurnToFront(ref IState<TurnManager> _state)
{
turnDequeue.AddFront(_state);
}
// 返却
public void Push(byte[] buf)
{
lock (this) {
pool.AddFront(buf);
}
}
public void ImmediateExecute(VEntity e)
{
gameplayEventQueue.AddFront(e);
Step(true);
}
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 AddBack(T input)
{
deque.AddFront(input);
}
public void TestClear()
{
int loops = 100;
Deque<int> deque = new Deque<int>();
for (int i = loops - 1; i >= 0; i--)
{
deque.AddFront(i);
}
deque.Clear();
Assert.AreEqual(0, deque.Count);
}
public void TestBulkInsert()
{
int loops = 100000;
Deque<int> deque = new Deque<int>();
deque.AddFront(loops - 1);
for (int i = 0; i < loops - 1; i++)
{
deque.Insert(deque.Count-1, i);
}
Deque<int> dequeCopy = new Deque<int>(deque);
for (int expected = 0; expected < loops; expected++)
{
int actual = deque.RemoveFront();
int actualCopy = dequeCopy[expected];
Assert.AreEqual(expected, actual, "Original deque item differs from expected value");
Assert.AreEqual(expected, actualCopy, "Copied deque item differs from expected value");
}
}
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]);
}
}
/// <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);
}
