public void StartSequence(Flow flow)
{
if (coroutineInstances == null)
{
coroutineInstances = new AotList();
}
if (loopRoutines == null)
{
loopRoutines = new AotList();
}
if (!isRunning || async)
{
isRunning = true;
coroutineInstance = CoroutineRunner.instance;
loopRoutine = coroutineInstance.ConvertTo <CoroutineRunner>().StartCoroutine(Loop());
coroutineInstances.Add(coroutineInstance);
loopRoutines.Add(loopRoutine);
Flow _flow = Flow.New();
_flow.Invoke(entered);
_flow.Dispose();
}
}
public void Enter(Flow flow)
{
IDictionary <Vector3, object> newDictionary = new Dictionary <Vector3, object>();
foreach (KeyValuePair <Vector3, object> item in databaseIn.GetValue <Database>().cells)
{
if (item.Key.y < index.GetValue <int>())
{
newDictionary.Add(new Vector3(item.Key.x, item.Key.y, item.Key.z), item.Value);
}
else
{
if (item.Key.y >= index.GetValue <int>() + rows.GetValue <int>())
{
newDictionary.Add(new Vector3(item.Key.x, item.Key.y - rows.GetValue <int>(), item.Key.z), item.Value);
}
}
}
newDatabase.cells = newDictionary;
newDatabase.rows = databaseIn.GetValue <Database>().rows - rows.GetValue <int>();
newDatabase.columns = databaseIn.GetValue <Database>().columns;
newDatabase.depth = databaseIn.GetValue <Database>().depth;
Flow _flow = Flow.New();
_flow.Invoke(exit);
_flow.Dispose();
}
public void Trigger(Flow flow)
{
Flow _flow = Flow.New();
if (!ascend.GetValue <bool>())
{
if (count < controlOutputs.Count - 1)
{
count++;
}
else
{
count = 0;
}
}
else
{
if (count > 0)
{
count--;
}
else
{
count = controlOutputs.Count - 1;
}
}
_flow.Invoke(controlOutputs["control_" + count]);
_flow.Dispose();
}
public void Trigger(Flow flow)
{
Flow _flow = Flow.New();
if (!ascend.GetValue <bool>())
{
if (count < multiValueInputs.Count - 1)
{
count++;
}
else
{
count = 0;
}
}
else
{
if (count > 0)
{
count--;
}
else
{
count = multiValueInputs.Count - 1;
}
}
_flow.Invoke(exit);
_flow.Dispose();
}
public IEnumerator Loop()
{
unscaledtime = Time.unscaledTime;
unscaledstartTime = Time.unscaledTime;
unscaledTimeElapsed = 0f;
unscaledTimeRemaining = delay.GetValue <float>();
realTime = Time.time;
realStartTime = Time.time;
realTimeElapsed = 0f;
realTimeRemaining = delay.GetValue <float>();
if (unscaled.GetValue <bool>())
{
while (unscaledTimeElapsed < delay.GetValue <float>())
{
unscaledtime = Time.time;
unscaledTimeElapsed = unscaledtime - unscaledstartTime;
unscaledTimeRemaining = delay.GetValue <float>() - unscaledTimeElapsed;
if (!destroyed)
{
Flow _loop = Flow.New();
_loop.Invoke(loop);
_loop.Dispose();
}
yield return(null);
}
}
else
{
while (realTimeElapsed < delay.GetValue <float>())
{
realTime = Time.time;
realTimeElapsed = realTime - realStartTime;
realTimeRemaining = delay.GetValue <float>() - realTimeElapsed;
if (!destroyed)
{
Flow _loop = Flow.New();
_loop.Invoke(loop);
_loop.Dispose();
}
yield return(null);
}
}
isRunning = false;
Flow _exit = Flow.New();
_exit.Invoke(exit);
_exit.Dispose();
}
public void BreakSequence(Flow flow)
{
if (coroutineInstances != null)
{
destroyed = true;
Flow _flow = Flow.New();
_flow.Invoke(breakOut);
_flow.Dispose();
}
}
public void Enter(Flow flow)
{
IDictionary <Vector3, object> newDictionary = new Dictionary <Vector3, object>();
bool after = true;
foreach (KeyValuePair <Vector3, object> item in databaseIn.GetValue <Database>().cells)
{
if (item.Key.z < index.GetValue <int>())
{
newDictionary.Add(item.Key, item.Value);
}
else
{
if (item.Key.z == databaseIn.GetValue <Database>().depth)
{
after = false;
}
break;
}
}
for (int h = 1; h <= databaseIn.GetValue <Database>().columns; h++)
{
for (int i = index.GetValue <int>(); i <= index.GetValue <int>() + depth.GetValue <int>(); i++)
{
for (int j = 1; j <= databaseIn.GetValue <Database>().rows; j++)
{
newDictionary.Add(new Vector3(h, j, i), null);
}
}
}
if (after)
{
foreach (KeyValuePair <Vector3, object> item in databaseIn.GetValue <Database>().cells)
{
if (item.Key.z >= index.GetValue <int>())
{
newDictionary.Add(new Vector3(item.Key.x, item.Key.y, item.Key.z + depth.GetValue <int>()), item.Value);
}
}
}
newDatabase.cells = newDictionary;
newDatabase.rows = databaseIn.GetValue <Database>().rows;
newDatabase.columns = databaseIn.GetValue <Database>().columns;
newDatabase.depth = databaseIn.GetValue <Database>().depth + depth.GetValue <int>();
Flow _flow = Flow.New();
_flow.Invoke(exit);
_flow.Dispose();
}
public void Enter(Flow flow)
{
IDictionary <Vector3, object> ADictionary = new Dictionary <Vector3, object>();
IDictionary <Vector3, object> BDictionary = new Dictionary <Vector3, object>();
int _depth = 0;
int _tempDepth = 0;
foreach (KeyValuePair <Vector3, object> item in databaseIn.GetValue <Database>().cells)
{
if (item.Key.z < index.GetValue <int>())
{
ADictionary.Add(new Vector3(item.Key.x, item.Key.y, item.Key.z), item.Value);
}
else
{
if (item.Key.z >= index.GetValue <int>())
{
if (_tempDepth != item.Key.z.ConvertTo <int>())
{
_tempDepth = item.Key.z.ConvertTo <int>();
_depth++;
}
BDictionary.Add(new Vector3(item.Key.x, item.Key.y, _depth), item.Value);
}
}
}
int BCount = _depth;
int ACount = databaseIn.GetValue <Database>().depth - _depth;
A.cells = ADictionary;
A.depth = ACount;
A.columns = databaseIn.GetValue <Database>().columns;
A.rows = databaseIn.GetValue <Database>().rows;
B.cells = BDictionary;
B.depth = BCount;
B.columns = databaseIn.GetValue <Database>().columns;
B.rows = databaseIn.GetValue <Database>().rows;
Flow _flow = Flow.New();
_flow.Invoke(exit);
_flow.Dispose();
}
private void Combine(Flow flow)
{
connectionCount = enter.connectedPorts.ToListPooled().Count;
if (!addedConnectedPorts)
{
controlConnections = new Dictionary <ControlConnection, bool>();
for (int i = 0; i < enter.validConnectedPorts.ToListPooled().Count; i++)
{
controlConnections.Add(enter.validConnectedPorts.ToListPooled()[i].connection, false);
}
addedConnectedPorts = true;
}
foreach (ControlConnection key in controlConnections.Keys.ToListPooled())
{
if (lastInvokeFrame >= lastInvokedFrame)
{
if (!controlConnections[key])
{
controlConnections[key] = true;
currentConnections++;
}
}
}
if (currentConnections == connectionCount - 1)
{
Debug.Log("FINISHED");
canExit = true;
}
if (canExit == true)
{
Flow _flow = Flow.New();
_flow.Invoke(exit);
_flow.Dispose();
currentConnections = 0;
canExit = false;
}
}
public void Enter(Flow flow)
{
IDictionary <Vector3, object> newDictionary = new Dictionary <Vector3, object>();
foreach (KeyValuePair <Vector3, object> item in databaseIn.GetValue <Database>().cells)
{
newDictionary.Add(item.Key, null);
}
newDatabase.cells = newDictionary;
newDatabase.rows = databaseIn.GetValue <Database>().rows;
newDatabase.columns = databaseIn.GetValue <Database>().columns;
newDatabase.depth = databaseIn.GetValue <Database>().depth;
Flow _flow = Flow.New();
_flow.Invoke(exit);
_flow.Dispose();
}
public IEnumerator Loop()
{
while (condition.GetValue <bool>())
{
if (!destroyed)
{
Flow _loop = Flow.New();
_loop.Invoke(loop);
_loop.Dispose();
}
yield return(null);
}
isRunning = false;
Flow _exit = Flow.New();
_exit.Invoke(exit);
_exit.Dispose();
}
private void Enter(Flow flow)
{
newDatabase = databaseIn.GetValue <Database>();
if (newDatabase.cells.Keys.Contains(new Vector3(column.GetValue <int>(), row.GetValue <int>(), depth.GetValue <int>())))
{
newDatabase.cells[new Vector3(column.GetValue <int>(), row.GetValue <int>(), depth.GetValue <int>())] = value.GetValue <object>();
Flow _flow = Flow.New();
_flow.Invoke(exit);
_flow.Dispose();
}
else
{
if (row.GetValue <int>() <= 0 || column.GetValue <int>() <= 0 || depth.GetValue <int>() <= 0)
{
throw new NullReferenceException("You can't have a 0 row, 0 column, or 0 depth database.");
}
else
{
throw new NullReferenceException("Cell in column '" + column.ToString() + "', row '" + row.ToString() + "', depth '" + depth.ToString() + "' does not exist.You do not have enough rows or columns.");
}
}
}
public void Enter(Flow flow)
{
if (index.GetValue <int>() > databaseIn.GetValue <Database>().rows)
{
throw new ArgumentOutOfRangeException();
}
else
{
IDictionary <Vector3, object> newDictionary = new Dictionary <Vector3, object>();
bool after = true;
foreach (KeyValuePair <Vector3, object> item in databaseIn.GetValue <Database>().cells)
{
if (item.Key.y < index.GetValue <int>())
{
newDictionary.Add(item.Key, item.Value);
}
else
{
if (item.Key.y == databaseIn.GetValue <Database>().rows)
{
after = false;
}
break;
}
}
for (int h = 1; h <= databaseIn.GetValue <Database>().depth; h++)
{
for (int i = index.GetValue <int>(); i <= index.GetValue <int>() + rows.GetValue <int>(); i++)
{
for (int j = 1; j <= databaseIn.GetValue <Database>().columns; j++)
{
newDictionary.Add(new Vector3(j, i, h), null);
}
}
}
if (after)
{
foreach (KeyValuePair <Vector3, object> item in databaseIn.GetValue <Database>().cells)
{
if (item.Key.y > index.GetValue <int>())
{
newDictionary.Add(new Vector3(item.Key.x, item.Key.y + rows.GetValue <int>(), item.Key.z), item.Value);
}
}
}
newDatabase.cells = newDictionary;
newDatabase.rows = databaseIn.GetValue <Database>().rows + rows.GetValue <int>();
newDatabase.columns = databaseIn.GetValue <Database>().columns;
newDatabase.depth = databaseIn.GetValue <Database>().depth;
Flow _flow = Flow.New();
_flow.Invoke(exit);
_flow.Dispose();
}
}
