public override IEnumerator ReceivePayload(VisualPayload payload)
{
//payload.VisualData.Bound.Data = payload.Data;
var metaEntries = EntryField.GetEntries(payload.Data);
var createdPayloads = new List <VisualPayload>();
foreach (var metaEntry in metaEntries)
{
// foreach ( var entry in entries )
// {
var newBound = payload.VisualData.Bound.CreateDependingBound(Name);
var newPayload = new VisualPayload(metaEntry.Last(), new VisualDescription(newBound));
//newBound.Data = metaEntry.Last();
createdPayloads.Add(newPayload);
}
MetaSelectionSet selectionManager = MetaSelectionSet.ConstructPayloadSelectionSet(
payload.VisualData.Bound, createdPayloads,
NormalState, SelectedState, NoneSelectedState,
NormalStateMulti, SelectedStateMulti, NoneSelectedStateMulti);
var iterator = selectionManager.TransmitAll();
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in Scope.GetEntries(payload.Data))
{
var textureSize = TextureSize.GetValue(entry);
var newTexture = new Texture2D(textureSize, textureSize);
var primaryColor = PrimaryColor.GetValue(entry);
var newPixels = Enumerable.Repeat(primaryColor, textureSize * textureSize).ToArray();
newTexture.SetPixels(newPixels);
newTexture.Apply();
TextureTarget.SetValue(newTexture, entry);
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in CsvField.GetEntries(payload.Data))
{
string csvString = CsvField.GetValue(entry);
if (string.IsNullOrEmpty(csvString))
{
yield break;
}
var values = csvString.Split(',');
NumberOfElementsTarget.SetValue(Mathf.FloorToInt(values.Length / 4f), entry);
for (int i = 0; i < values.Length / 4; i++)
{
Entry1Target.SetValue(values[4 * i], entry);
Entry2Target.SetValue(values[4 * i + 1], entry);
Entry3Target.SetValue(values[4 * i + 2], entry);
Entry4Target.SetValue(values[4 * i + 3], entry);
var iterator = PerEntryState.Transmit(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in ArrayTarget.GetEntries(payload.Data))
{
var numberOfInts = NumberOfInts.GetValue(entry);
var outMutable = new List <MutableObject>();
for (int i = 0; i < numberOfInts; i++)
{
outMutable.Add(new MutableObject()
{
{ "Index", i }
});
}
ArrayTarget.SetValue(outMutable, entry);
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
var filledGraph = VisualizerFactory.InstantiateFilledGraph();
filledGraph.Initialize(this, payload);
AssignStates(filledGraph);
var mainColor = MainColor.GetFirstValue(payload.Data);
foreach (var entry in EntryField.GetEntries(payload.Data))
{
filledGraph.AddPoint(ZAxis.GetValue(entry),
YAxis.GetValue(entry));
}
filledGraph.SetGraphData(
mainColor);
filledGraph.ApplyPoints();
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public IEnumerator Select(VisualPayload payload)
{
bool sendNormal = !SelectedList.Any();
UnSelectedList.Remove(payload);
SelectedList.Add(payload);
payload.VisualData.Bound.ClearBounds();
var iterator = SelectedState.Transmit(payload);
while (iterator.MoveNext())
{
yield return(null);
}
if (sendNormal)
{
iterator = SendUnselected();
while (iterator.MoveNext())
{
yield return(null);
}
}
iterator = TransmitMultiStates();
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var textureSize = TextureSize.GetFirstValue(payload.Data);
var newTexture = new Texture2D(textureSize, textureSize);
var newPixels = new Color[textureSize * textureSize];
var gradient = ColorGradient.GetFirstValue(payload.Data);
for (int x = 0; x < textureSize; x++)
{
for (int y = 0; y < textureSize; y++)
{
var proportion = x / (float)textureSize;
var color = gradient.Evaluate(proportion);
newPixels[x + y * textureSize] = color;
}
}
newTexture.SetPixels(newPixels);
newTexture.Apply();
TextureTarget.SetValue(newTexture, payload.Data);
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var gameEventIterator = PopulateGameEventContainer(payload);
while (gameEventIterator.MoveNext())
{
yield return(null);
}
if (EventContainer == null)
{
Debug.LogError("Aborting; EventContainer was null.");
yield break;
}
//var eventContainerMutableObject = MutableObject.FromObject( eventContainer );
var eventContainerMutableObject = EventContainerToMutableObject(EventContainer.Rounds);
GameEventsTarget.SetValue(eventContainerMutableObject, payload.Data);
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in CommaSeparatedValues.GetEntries(payload.Data))
{
string csvString = CommaSeparatedValues.GetValue(entry);
if (string.IsNullOrEmpty(csvString))
{
yield break;
}
var values = csvString.Split(',');
NumberOfElementsTarget.SetValue(values.Length, entry);
foreach (var value in values)
{
SingleEntryTarget.SetValue(value, entry);
var iterator = PerEntryState.Transmit(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in Scope.GetEntries(payload.Data))
{
try
{
var repeatBytes = RepeatByBytes.GetValue(entry);
var stringData = StringInput.GetValue(entry);
var bitStream = InternalArrayBitstream.GenerateBitStreamFromLetterNumbers(stringData);
bitStream.AdvanceByBytes = repeatBytes;
BitStreamTarget.SetValue(bitStream, entry);
}
catch
{
Debug.LogError("Bitstream cannot be created!");
var stringData2 = StringInput.GetValue(entry);
}
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
CacheSchema();
var numberFromMutable = MutableFromCache.GetFirstValue(payload.Data);
Debug.Log("Mutable value is " + numberFromMutable);
SetUpTestExpression();
var boundsList = Expression.ResolveExpression(ChainView.Instance.Chain.RootBoundingBoxes);
Debug.Log("Payload expression located " + boundsList.Count);
UnCacheSchema();
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
var filesize = FileSize.GetFirstValue(payload.Data);
var significantStream = SignificantBitstream
.GetFirstValue(payload.Data);
var insignificantStream = InsignificantBitStream
.GetFirstValue(payload.Data);
var sizeOffset = SizeOffset.GetFirstValue(payload.Data);
var csView = Assembler.ConstructCsViewStep1(significantStream,
insignificantStream, filesize, sizeOffset /* * filesize/700000*/);
csView.Initialize(this, payload);
csView.SetTexture(VisualizerTexture.GetFirstValue(payload.Data));
CsVisualizerTarget.SetValue(new CsVisContainer(csView), payload.Data);
var newPayload = new VisualPayload(payload.Data, new VisualDescription(csView.Bound));
var iterator = Router.TransmitAll(newPayload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var samplerField = new MutableField <T> {
AbsoluteKey = FieldKey.GetFirstValue(payload.Data)
};
if (!samplerField.CouldResolve(payload.Data))
{
Debug.Log("Couldn't resolve assignment switch " + samplerField.AbsoluteKey + ". Using default value.");
AssignmentTarget.SetValue(GetDefaultValue(), payload.Data);
}
else
{
try
{
foreach (var entry in AssignmentTarget.GetEntries(payload.Data))
{
AssignmentTarget.SetValue(samplerField.GetValue(entry), entry);
}
}
catch (Exception e)
{
Debug.LogError("Assignment switch invalid! Probably can't target " + AssignmentTarget.AbsoluteKey + " from theoretical field " + samplerField.AbsoluteKey + "! Exception: " + e);
throw e;
}
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public IEnumerator RunVolumeTest()
{
MutableObject testObj = new MutableObject();
testObj.Add("height", 3f);
testObj.Add("heightMax", 5f);
VisualPayload payload = new VisualPayload(
testObj,
new VisualDescription(BoundingBox.ConstructBoundingBox(GetType().Name)));
// create a volume controller
RectangularVolumeController volumeController = new RectangularVolumeController();
volumeController.YAxis.AbsoluteKey = "height";
volumeController.YMax.AbsoluteKey = "heightMax";
// send the test mutable
var iterator = volumeController.StartReceivePayload(payload);
while (iterator.MoveNext( ))
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var iterator = UpdateExecutionId(payload.Data);
while (iterator.MoveNext())
{
yield return(null);
}
var executionPerformanceCommand = new GetExecutionPerformanceCommand(FoundExecutionId);
iterator = CommandProcessor.Execute(executionPerformanceCommand);
while (iterator.MoveNext())
{
yield return(null);
}
var statsMutable = ConstructStatsMutable(executionPerformanceCommand.InstructionCount);
ExecutionStatsTarget.SetValue(statsMutable, payload.Data);
iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var newBound = payload.VisualData.Bound.CreateDependingBound(Name);
//var bound = payload.VisualData.Bound;
newBound.transform.parent = payload.VisualData.Bound.transform.parent;
payload.VisualData.Bound.transform.parent = newBound.transform;
var constantSizer = newBound.gameObject.AddComponent <CameraConstantSizeObject>();
constantSizer.Size = SizeField.GetFirstValue(payload.Data);
//cameraFacer.CameraFacing = CameraFacing.GetFirstValue( payload.Data );
VisualPayload newPayload = new VisualPayload(payload.Data, new VisualDescription(newBound));
var iterator = Router.TransmitAll(newPayload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
Payload = payload;
ScoreFromJsonFilter.DataLoaded += DataReady;
foreach (var entry in FilePath.GetEntries(payload.Data))
{
DataIsReady = false;
var fileName = FilePath.GetValue(entry);
ScoreFromJsonFilter.LoadData(fileName);
while (!DataIsReady)
{
yield return(null);
}
yield return(null);
// Let this breathe a bit, because currently the above is essentially a blocking operation
var iterator = Router.TransmitAll(PayloadToTransmit);
while (iterator.MoveNext())
{
yield return(null);
}
}
ScoreFromJsonFilter.DataLoaded -= DataReady;
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
if (DataShare == null)
{
DataShare = new NodeDataShare <Socket>();
}
var IPs = Dns.GetHostAddresses(TargetAddress.GetFirstValue(payload.Data));
var newSocket = new Socket(
AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
try
{
newSocket.Connect(IPs.First(), TargetPort.GetFirstValue(payload.Data));
DataShare[GroupId.GetFirstValue(payload.Data)] = newSocket;
}
catch (Exception e)
{
Debug.LogError("Could not connect to socket! Error: " + e);
}
yield break;
}
public IEnumerator Deselect(VisualPayload payload)
{
SelectedList.Remove(payload);
UnSelectedList.Add(payload);
payload.VisualData.Bound.ClearBounds();
IEnumerator iterator;
if (!SelectedList.Any())
{
iterator = SendNoneSelected();
while (iterator.MoveNext())
{
yield return(null);
}
}
else
{
iterator = NormalState.Transmit(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
iterator = TransmitMultiStates();
while (iterator.MoveNext())
{
yield return(null);
}
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
var memoryGraph = VisualizerFactory.InstantiateMemoryGraph();
memoryGraph.Initialize(this, payload);
foreach (var entry in DashStartPosition.GetEntries(payload.Data))
{
var startPosition = DashStartPosition.GetValue(entry);
var dashWidth = DashWidth.GetValue(entry);
var dashDepth = DashDepth.GetValue(entry);
var elevation = Elevation.GetValue(entry);
var dashColor = DashColor.GetValue(entry);
memoryGraph.AddDash(
startPosition,
new Vector3(dashWidth, elevation, dashDepth),
dashColor);
yield return(null);
}
yield return(null);
memoryGraph.ApplyPoints();
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var filename = TraceFilename.GetFirstValue(payload.Data);
var trace = Trace.LoadFromFile(filename);
var newExecution = new Execution
{
CbAuthor = CbAuthor.GetFirstValue(payload.Data),
CbId = 0,
ExecutionId = (uint)ExecutionID.GetFirstValue(payload.Data),
PovType = PovType.GetFirstValue(payload.Data),
RequestId = (uint)RequestId.GetFirstValue(payload.Data),
ServiceId = new ServiceIdentifier(),
RequestNature = RequestNature.GetFirstValue(payload.Data),
Success = Success.GetFirstValue(payload.Data),
Traces = new List <Trace> {
trace
}
};
var executionMutable = ExecutionAdapter.ExecutionToMutable(
newExecution,
IncludeMemory.GetFirstValue(payload.Data),
PovType.GetFirstValue(payload.Data));
ExecutionTarget.SetValue(executionMutable, payload.Data);
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var groupId = GroupId.GetFirstValue(payload.Data);
var singleElement = SingleElement.GetFirstValue(payload.Data);
var targetElementCount = NumberOfEntries.GetFirstValue(payload.Data);
if (!DataShare.ContainsKey(groupId))
{
DataShare[groupId] = new List <MutableObject>();
}
DataShare[groupId].Add(singleElement);
if (DataShare[groupId].Count >= targetElementCount)
{
var dataList = DataShare[groupId];
RecombinedListTarget.SetValue(dataList, payload.Data);
DataShare[groupId] = new List <MutableObject>();
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
SelectGroups(payload.Data);
VisualPayload selectedPayload;
if (NewPayloadOnly.GetFirstValue(payload.Data))
{
var newMutable = new MutableObject();
newMutable[EntryFieldName] = SelectedList;
selectedPayload = new VisualPayload(
newMutable,
payload.VisualData);
}
else
{
selectedPayload = payload;
SelectedListTarget.SetValue(SelectedList, payload.Data);
}
var iterator = SelectedSet.Transmit(selectedPayload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var rightListDictionary = new Dictionary <T, MutableObject>();
foreach (var entry in RightListEntries.GetEntries(payload.Data))
{
var discriminant = RightDiscriminant.GetValue(entry);
var mutable = entry.Last();
rightListDictionary.Add(discriminant, mutable);
}
foreach (var entry in LeftListScope.GetEntries(payload.Data))
{
var discriminant = LeftDiscriminant.GetValue(entry);
var foundMutable = new MutableObject();
if (rightListDictionary.ContainsKey(discriminant))
{
foundMutable = rightListDictionary[discriminant];
}
JoinElementTarget.SetValue(foundMutable, entry);
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
protected override SequencedRepeatPair ProduceTransmissionFunc(VisualPayload payload)
{
var sequencedPair = new SequencedRepeatPair();
var transmissionStack = new Queue <VisualPayload>();
PopulateTransmissions(transmissionStack, payload);
//var finalTransmission = new TransmitWaitPair(payload, EndSequenceState);
if (!transmissionStack.Any())
{
sequencedPair.PerStepFuncComplete = () => true;
sequencedPair.RepeatPairIsCompleted = true;
}
else
{
sequencedPair.PerStepFuncComplete = () =>
{
var transmit = transmissionStack.Dequeue();
JobManager.Instance.StartJob(
PerSequenceState.Transmit(transmit), jobName: "Per Step", startImmediately: true,
maxExecutionsPerFrame: 100);
return(!transmissionStack.Any());
};
}
sequencedPair.ConcludeFunc = ProduceDefaultConclude(payload);
return(sequencedPair);
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in Scope.GetEntries(payload.Data))
{
var bitstream1 = FirstStream.GetValue(entry);
var bitstream2 = SecondStream.GetValue(entry);
var secondStreamProportion = SecondStreamProportion.GetValue(entry);
var randomSeed = RandomSeed.GetValue(entry);
var combinedStream = new RandomlyInterspersedBitstream(bitstream1,
bitstream2, secondStreamProportion, randomSeed);
combinedStream.AdvanceByBytes = AdvanceByBytes.GetValue(entry);
NewBitstreamTarget.SetValue(combinedStream, entry);
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
private void RenderItemLabelsDiscrete(VisualPayload payload, List <ICriterionMetaSelector> criteria)
{
var sizePeriod = SizePeriod.GetLastKeyValue(payload.Data);
const float shiftRatio = 0.50f; // 0.50 means 'centered' todo: make this a setting (mutable field)
// Determine how many labels to create, based on the maximum 'index' (coordinate) of the axis in question
var entries = AxisIndexVariable.GetEntries(payload.Data);
var maxVar = -1;
foreach (var e in entries)
{
maxVar = Mathf.Max(maxVar, AxisIndexVariable.GetValue(e));
}
if (maxVar == -1)
{
return;
}
maxVar += 1;
//var numLabels =
// //!entries.Any() ? 0 :
// entries.Max( e => AxisIndexVariable.GetValue( e ) ) + 1;
RenderItemLabelsInternal(payload, maxVar, sizePeriod, shiftRatio, true, criteria);
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in CsIndex.GetEntries(payload.Data))
{
ChallengeSetInfo csInfo;
if (CsIndex.GetValue(entry) > 0)
{
var csIndex = (uint)CsIndex.GetValue(entry);
var csInfoCommand = new GetCsInfoCommand(csIndex);
var commandIterator = CommandProcessor.Execute(csInfoCommand);
while (commandIterator.MoveNext())
{
yield return(null);
}
csInfo = csInfoCommand.CsInfo;
}
else
{
csInfo = DefaultChallengeSetInfo;
}
CsInfoTarget.SetValue(CsStatsAdapter.PopulateCsStats(csInfo), entry);
}
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
protected sealed override IEnumerator ProcessPayload(VisualPayload payload)
{
var windowVisualizer = GetWindowVisualizer(payload);
windowVisualizer.RequestColor = RequestColorField.GetFirstValue(payload.Data);
windowVisualizer.FilamentColor = FilamentColorField.GetFirstValue(payload.Data);
windowVisualizer.RequestTeamLogo = RequestTeamLogoField.GetFirstValue(payload.Data);
windowVisualizer.BinaryId = BinaryIdField.GetFirstValue(payload.Data);
windowVisualizer.BinsetTeamIndices = BinsetTeamIndices.GetFirstValue(payload.Data);
windowVisualizer.BinsetShortName = BinsetShortNameField.GetFirstValue(payload.Data);
windowVisualizer.RequestId = RequestIdField.GetFirstValue(payload.Data);
windowVisualizer.RequestNature = RequestNatureField.GetFirstValue(payload.Data);
windowVisualizer.ElementCount = ElementCountField.GetFirstValue(payload.Data);
// Order issue, must come after RequestNature!
windowVisualizer.Success = SuccessField.GetFirstValue(payload.Data);
windowVisualizer.PovType = PovTypeField.GetFirstValue(payload.Data);
windowVisualizer.ShowDisassembly = ShowDisassemblyField.GetFirstValue(payload.Data);
windowVisualizer.ShowComms = ShowCommsField.GetFirstValue(payload.Data);
yield return(null);
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
var csIndex = (uint)CsIndex.GetFirstValue(payload.Data);
//var csInfoCommand = new getcs
#region Data query
var csStatsCommand = new GetCsInfoCommand(csIndex);
var commandIterator = CommandProcessor.Execute(csStatsCommand);
while (commandIterator.MoveNext())
{
yield return(null);
}
CsStatsTarget.SetValue(PopulateCsStats(csStatsCommand.CsInfo), payload.Data);
#endregion
#region Use default information
//CsStatsTarget.SetValue( PopulateCsStats( DefaultChallengeSetStats ), payload.Data );
#endregion
var binsetCommand = new GetBinsetCommand(csStatsCommand.CsInfo.Binary);
commandIterator = CommandProcessor.Execute(binsetCommand);
while (commandIterator.MoveNext())
{
yield return(null);
}
var binList = new List <BinaryStats>();
foreach (var binId in binsetCommand.BinIds)
{
var binInfoCommand = new GetBinaryStatsCommand(binId);
commandIterator = CommandProcessor.Execute(binInfoCommand);
while (commandIterator.MoveNext())
{
yield return(null);
}
binList.Add(binInfoCommand.BinStats);
}
BinaryStatsTarget.SetValue(PopulateBinaryStats(
binList), payload.Data);
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
