public void NormalUse()
{
Assert.IsTrue(dictenum.MoveNext());
Assert.AreEqual(dictenum.Current, new KeyValuePair <string, string>("R", "C"));
Assert.IsTrue(dictenum.MoveNext());
Assert.AreEqual(dictenum.Current, new KeyValuePair <string, string>("S", "A"));
Assert.IsTrue(dictenum.MoveNext());
Assert.AreEqual(dictenum.Current, new KeyValuePair <string, string>("T", "B"));
Assert.IsFalse(dictenum.MoveNext());
}
public void DoDispose()
{
hashset.Add(5);
hashset.Add(8);
hashset.Add(5);
SCG.IEnumerator <int> e = hashset.GetEnumerator();
e.MoveNext();
e.MoveNext();
e.Dispose();
}
public void MoveNextAfterUpdate()
{
hashset.Add(5);
hashset.Add(8);
hashset.Add(5);
SCG.IEnumerator <int> e = hashset.GetEnumerator();
e.MoveNext();
hashset.Add(99);
e.MoveNext();
}
public void KeysEnumerator()
{
SCG.IEnumerator <string> keys = dict.Keys.GetEnumerator();
Assert.AreEqual(3, dict.Keys.Count);
Assert.IsTrue(keys.MoveNext());
Assert.AreEqual("R", keys.Current);
Assert.IsTrue(keys.MoveNext());
Assert.AreEqual("S", keys.Current);
Assert.IsTrue(keys.MoveNext());
Assert.AreEqual("T", keys.Current);
Assert.IsFalse(keys.MoveNext());
}
public void ValuesEnumerator()
{
SCG.IEnumerator <string> values = dict.Values.GetEnumerator();
Assert.AreEqual(3, dict.Values.Count);
Assert.IsTrue(values.MoveNext());
Assert.AreEqual("C", values.Current);
Assert.IsTrue(values.MoveNext());
Assert.AreEqual("A", values.Current);
Assert.IsTrue(values.MoveNext());
Assert.AreEqual("B", values.Current);
Assert.IsFalse(values.MoveNext());
}
public void MoveNextAfterUpdate()
{
hashset.Add(5);
hashset.Add(8);
hashset.Add(5);
SCG.IEnumerator <int> e = hashset.GetEnumerator();
e.MoveNext();
hashset.Add(99);
Assert.Throws <CollectionModifiedException>(() => e.MoveNext());
}
private void CreateSpellInstances()
{
Array <Spatial> projectileList;
string currentType;
Spatial container;
Spatial projectile = null;
SCG.IEnumerator <PackedScene> it = projectilePrefabList.GetEnumerator();
int index = 0;
int amount;
while (it.MoveNext())
{
projectileList = new Array <Spatial>();
container = GetChild <Spatial>(index);
amount = projectileAmountList[index++];
for (int i = 0; i < amount; i++)
{
projectile = it.Current.Instance() as Spatial;
projectile.Translation = inactiveTranslation;
projectile.Name = this.CreateUniqueNodeName(projectile);
projectile.Call(this.GetMethodSetManager(), this);
projectileList.Add(projectile);
container.CallDeferred(this.GetGDMethodAddChild(), projectile);
}
if (amount > 0)
{
currentType = this.Call <string>(projectile, this.GetMethodGetNodeType());
availableProjectileMap.Add(currentType, projectileList);
}
}
}
public void RequestResources()
{
if (nodeRenderScenePathList != null)
{
SCG.IEnumerator <string> it = nodeRenderScenePathList.GetEnumerator();
PackedScene ps;
Spatial s;
string instanceId;
int index = 0;
while (it.MoveNext())
{
ps = ResourceLoader.Load <PackedScene>(it.Current);
s = ps.Instance() as Spatial;
instanceId = s.GetInstanceId().ToString();
nodeRenderSceneMap.Add(instanceId, s);
nodeRenderIdsList.Add(index++, instanceId);
if (OS.IsDebugBuild())
{
GD.PushWarning("RequestFinished: " + s.Name);
}
}
if (OS.IsDebugBuild())
{
GD.PushWarning("All Resources requests finished!");
}
}
}
private void CreateLaserDeviceInstances()
{
Array <Spatial> laserDeviceList;
string currentType;
Spatial container;
Spatial laserDevice = null;
SCG.IEnumerator <PackedScene> it = laserDevicePSList.GetEnumerator();
int index = 0;
int finalAmount = laserDeviceAmount * specialistAmount;
while (it.MoveNext())
{
laserDeviceList = new Array <Spatial>();
container = GetChild <Spatial>(index++);
for (int i = 0; i < finalAmount; i++)
{
laserDevice = it.Current.Instance() as Spatial;
laserDevice.Translation = inactiveTranslation;
laserDevice.Name = this.CreateUniqueNodeName(laserDevice);
laserDevice.Call(this.GetMethodSetManager(), this);
container.CallDeferred(this.GetGDMethodAddChild(), laserDevice);
laserDeviceList.Add(laserDevice);
}
currentType = this.Call <string>(laserDevice, this.GetMethodGetNodeType());
availableLaserDeviceMap.Add(currentType, laserDeviceList);
}
}
private void ComputeActionInputUnionMask()
{
SCG.IEnumerator <int> it = actionInputBufferList.GetEnumerator();
actionInputUnionMask = PLANT_DEVICE_MASK | CHANGE_SLOT_MASK | EXECUTE_SKILL_MASK;
while (it.MoveNext())
{
actionInputUnionMask &= it.Current;
}
}
/// <summary>
/// Fills states 0 up to other.size with other's states.
/// </summary>
/// <param name="other"></param>
public void FillStates(NFA other)
{
for (state i = 0; i < other.size; ++i)
{
for (state j = 0; j < other.size; ++j)
{
transTable[i][j] = other.transTable[i][j];
}
}
SCG.IEnumerator <input> cE = other.inputs.GetEnumerator();
while (cE.MoveNext())
{
inputs.Add(cE.Current);
}
}
public static Array ConvertToDefaultArray <T>(
this Godot.Object gdobj, Array <T> array)
{
Array defaultArray = new Array();
if (defaultArray != null)
{
SCG.IEnumerator <T> it = array.GetEnumerator();
while (it.MoveNext())
{
defaultArray.Add(it.Current);
}
}
return(defaultArray);
}
private void UpdateLabels()
{
SCG.IEnumerator <string> it = gameplayKeyList.GetEnumerator();
int index = 0;
while (it.MoveNext())
{
if (lastGameplayDataMap.Contains(it.Current))
{
labels[index++].Text = GetFixedLabelText(it.Current);
}
}
for (int i = index; i < labels.Length; i++)
{
labels[i].Text = "";
}
}
public void Show()
{
Console.Write("DFA start state: {0}\n", start);
Console.Write("DFA final state(s): ");
SCG.IEnumerator <state> iE = final.GetEnumerator();
while (iE.MoveNext())
{
Console.Write(iE.Current + " ");
}
Console.Write("\n\n");
foreach (SCG.KeyValuePair <KeyValuePair <state, input>, state> kvp in transTable)
{
Console.Write("Trans[{0}, {1}] = {2}\n", kvp.Key.Key, kvp.Key.Value, kvp.Value);
}
}
protected static int countItems(SCG.IEnumerable <T> items)
{
ICollectionValue <T> jtems = items as ICollectionValue <T>;
if (jtems != null)
{
return(jtems.Count);
}
int count = 0;
using (SCG.IEnumerator <T> e = items.GetEnumerator())
while (e.MoveNext())
{
count++;
}
return(count);
}
public void IList_Generic_CurrentAtEnd_AfterAdd(int count)
{
if (!IsReadOnly && !AddRemoveClear_ThrowsNotSupported)
{
SCG.IList <T> collection = GenericIListFactory(count);
using (SCG.IEnumerator <T> enumerator = collection.GetEnumerator())
{
while (enumerator.MoveNext())
{
; // Go to end of enumerator
}
T current = default(T);
if (Enumerator_Current_UndefinedOperation_Throws)
{
Assert.Throws <InvalidOperationException>(() => enumerator.Current); // enumerator.Current should fail
}
else
{
current = enumerator.Current;
Assert.Equal(default(T), current);
}
// Test after add
int seed = 3538963;
for (int i = 0; i < 3; i++)
{
collection.Add(CreateT(seed++));
if (Enumerator_Current_UndefinedOperation_Throws)
{
Assert.Throws <InvalidOperationException>(() => enumerator.Current); // enumerator.Current should fail
}
else
{
current = enumerator.Current;
Assert.Equal(default(T), current);
}
}
}
}
}
public static Array <T> GetNodeList <T>(this Node gdNode,
Node caller, Array <NodePath> nodePathList) where T : Godot.Object
{
Array <T> nodeList = new Array <T>();
if (nodePathList != null)
{
SCG.IEnumerator <NodePath> it = nodePathList.GetEnumerator();
while (it.MoveNext())
{
nodeList.Add(caller.GetNode <T>(it.Current));
}
}
else
{
GD.PushWarning("NodePathList called by '" + caller.Name + "' is null");
}
return(nodeList);
}
private void UpdateRankingLabels(int index)
{
string indexText = index.ToString();
if (rankingMap.Contains(indexText))
{
rankingControls[index].Visible = true;
Label[] labels = labelsMap[index];
Dictionary dataMap = rankingMap[indexText] as Dictionary;
SCG.IEnumerator <string> it = rankingKeyList.GetEnumerator();
int labelIndex = 0;
while (it.MoveNext())
{
labels[labelIndex++].Text = GetFixedLabelText(dataMap, it.Current);
}
}
else
{
rankingControls[index].Visible = false;
}
}
public static T[] GetNodes <T>(this Node gdNode,
Node caller, Array <NodePath> nodePathList) where T : Godot.Object
{
if (nodePathList != null)
{
int index = 0;
T[] nodes = new T[nodePathList.Count];
SCG.IEnumerator <NodePath> it = nodePathList.GetEnumerator();
while (it.MoveNext())
{
nodes[index++] = caller.GetNode <T>(it.Current);
}
return(nodes);
}
else
{
GD.PushWarning("NodePathList called by '" + caller.Name + "' is null");
}
return(new T[0]);
}
private void LoadResources()
{
if (resourcePathList != null)
{
int index;
string[] split;
SCG.IEnumerator <string> it = resourcePathList.GetEnumerator();
while (it.MoveNext())
{
split = it.Current.Split("/");
index = split.Length - 1;
Resource res = ResourceLoader.Load(it.Current);
if (res != null)
{
globalResource.Call(this.GetMethodPut(), split[index].Split(".")[0], res);
}
}
}
loaded = true;
}
/// <summary>
/// Subset machine that employs the powerset construction or subset construction algorithm.
/// It creates a DFA that recognizes the same language as the given NFA.
/// </summary>
public static DFA SubsetConstruct(NFA nfa)
{
DFA dfa = new DFA();
// Sets of NFA states which is represented by some DFA state
Set <Set <state> > markedStates = new Set <Set <state> >();
Set <Set <state> > unmarkedStates = new Set <Set <state> >();
// Gives a number to each state in the DFA
HashDictionary <Set <state>, state> dfaStateNum = new HashDictionary <Set <state>, state>();
Set <state> nfaInitial = new Set <state>();
nfaInitial.Add(nfa.initial);
// Initially, EpsilonClosure(nfa.initial) is the only state in the DFAs states
// and it's unmarked.
Set <state> first = EpsilonClosure(nfa, nfaInitial);
unmarkedStates.Add(first);
// The initial dfa state
state dfaInitial = GenNewState();
dfaStateNum[first] = dfaInitial;
dfa.start = dfaInitial;
while (unmarkedStates.Count != 0)
{
// Takes out one unmarked state and posteriorly mark it.
Set <state> aState = unmarkedStates.Choose();
// Removes from the unmarked set.
unmarkedStates.Remove(aState);
// Inserts into the marked set.
markedStates.Add(aState);
// If this state contains the NFA's final state, add it to the DFA's set of
// final states.
if (aState.Contains(nfa.final))
{
dfa.final.Add(dfaStateNum[aState]);
}
SCG.IEnumerator <input> iE = nfa.inputs.GetEnumerator();
// For each input symbol the NFA knows...
while (iE.MoveNext())
{
// Next state
Set <state> next = EpsilonClosure(nfa, nfa.Move(aState, iE.Current));
// If we haven't examined this state before, add it to the unmarkedStates,
// and make up a new number for it.
if (!unmarkedStates.Contains(next) && !markedStates.Contains(next))
{
unmarkedStates.Add(next);
dfaStateNum.Add(next, GenNewState());
}
KeyValuePair <state, input> transition = new KeyValuePair <state, input>();
transition.Key = dfaStateNum[aState];
transition.Value = iE.Current;
dfa.transTable[transition] = dfaStateNum[next];
}
}
return(dfa);
}
public void Empty()
{
SCG.IEnumerator <int> e = hashset.GetEnumerator();
Assert.IsFalse(e.MoveNext());
}