// This dialogue greets the user (as a result of face recognition input
// from the vision process.
private void GenerateGreetingDialogue()
{
Boolean isAlwaysAvailable = true;
double inputTimeoutInterval = double.MaxValue; // No reason to have a timeout here, since the dialogue is _activated_ upon receiving matching input.
int inputMaximumRepetitionCount = 1; // Greet the user only once.
Dialogue greetingDialogue = new Dialogue("GreetingDialogue", isAlwaysAvailable);
// The agent checks if a face has just been detected.
// NOTE: This requires, of course, that the Vision process should send the
// appropriate message, in this case "FaceDetected".
InputItem itemGD1 = new InputItem("GD1", null, inputTimeoutInterval, inputMaximumRepetitionCount, "", "");
itemGD1.AllowVisionInput = true; // Default value = false. Must set to true for this dialogue item.
//itemGD1.DoReset = false; // Make sure that the greeting runs only once.
InputAction inputActionGD1 = new InputAction(greetingDialogue.Context, "GD2");
inputActionGD1.RequiredSource = AgentConstants.VISION_INPUT_TAG;
inputActionGD1.PatternList.Add(new Pattern("FaceDetected"));
itemGD1.InputActionList.Add(inputActionGD1);
greetingDialogue.DialogueItemList.Add(itemGD1);
OutputItem itemGD2 = new OutputItem("GD2", AgentConstants.SPEECH_OUTPUT_TAG, null, false, 1);
OutputAction outputActionGD2 = new OutputAction("", "");
outputActionGD2.PatternList.Add(new Pattern("Hello user"));
itemGD2.OutputAction = outputActionGD2;
greetingDialogue.DialogueItemList.Add(itemGD2);
agent.DialogueList.Add(greetingDialogue);
}
public DirectionActionChange(Hand hand, OutputAction action, Direction direction, bool state)
{
this.hand = hand;
this.action = action;
this.direction = direction;
this.state = state;
}
public static IDisposable BindAction <T>(this IReactive <UIView> reactive, OutputAction <T> action)
{
return(Observable.Using(
() => action.Enabled.Subscribe(e => { reactive.Base.UserInteractionEnabled = e; }),
_ => reactive.Base.Rx().Tap()
)
.Subscribe(action.Inputs));
}
static void Main()
{
var utils = new Utilities();
var unsortedCollection = utils.GetRandomNumbersCollection(elementsCount, 100);
OutputAction <int> outputAction = GetOutputAction <int>(utils);
PerfromSort(new MergeSorter <int>(), unsortedCollection, outputAction, isAscendingSort);
PerfromSort(new QuickSorter <int>(), unsortedCollection, outputAction, isAscendingSort);
Console.ReadKey();
}
public async Task ArrayToTableString(byte[] output, int outputLenth = 0)
{
if (output.Length == 0)
{
throw new ArgumentException("File is empty");
}
if (OutputActionAsync.GetInvocationList() == null || OutputActionAsync.GetInvocationList().Length == 0)
{
isProgressAsync = false;
}
else
{
isProgressAsync = true;
}
var writingLenth = outputLenth != 0 ? outputLenth : output.Length;
for (int i = 0; i < writingLenth; i++)
{
if (i % byteLineWidth == 0 && i != 0)
{
if (isProgressAsync)
{
await OutputActionAsync?.Invoke("|\n");
await OutputActionAsync?.Invoke($"{RowLine}\n");
}
else
{
OutputAction?.Invoke("|\n");
OutputAction?.Invoke($"{RowLine}\n");
}
}
if (isProgressAsync)
{
await OutputActionAsync?.Invoke(AlignCentre(output[i]));
}
else
{
OutputAction?.Invoke(AlignCentre(output[i]));
}
WritingProgess = (double)(i + 1) / writingLenth;
}
Finalize?.Invoke();
}
/// <summary>
/// Sets the raw output.
/// Used internally.
/// </summary>
/// <param name="rawOutput">The raw output.</param>
void ICanParseOutput.SetRawOutput(IEnumerable <string>?rawOutput)
{
string[] outputlines = Array.Empty <string>();
T? parsed = default;
if (rawOutput != null)
{
outputlines = rawOutput.ToArray();
parsed = OutputParser.Parse(outputlines);
}
RawOutputAction?.Invoke(outputlines);
if (parsed != null)
{
OutputAction?.Invoke(parsed);
}
}
private static void PerfromSort <T>(SorterBase <T> sorter, ICollection <T> unsortedCollection,
OutputAction <T> outputAction, bool isAsc)
where T : IComparable
{
DisplaySortCaption(sorter, unsortedCollection.Count);
outputAction(unsortedCollection, nameof(unsortedCollection));
sw.Start();
var sortedCollection = sorter.Sort(unsortedCollection, isAsc);
sw.Stop();
outputAction(sortedCollection, nameof(sortedCollection));
DisplaySortPerformanceResults();
}
public static IDisposable BindAction <T>(this IReactive <View> reactive, OutputAction <T> action, ButtonEventType eventType = ButtonEventType.Tap)
{
IObservable <Unit> eventObservable = Observable.Empty <Unit>();
switch (eventType)
{
case ButtonEventType.Tap:
eventObservable = reactive.Base.Rx().Tap();
break;
case ButtonEventType.LongPress:
eventObservable = reactive.Base.Rx().LongPress();
break;
}
return(Observable.Using(
() => action.Enabled.Subscribe(e => { reactive.Base.Enabled = e; }),
_ => eventObservable
)
.Subscribe(action.Inputs));
}
public async Task ArrayToTableString(bool[] output, int outputLenth = 0)
{
if (output.Length == 0)
{
throw new ArgumentException("File is empty");
}
var writingLenth = outputLenth != 0 ? outputLenth : output.Length;
for (int i = 0; i < writingLenth; i++)
{
if (i % binaryLineWidth == 0 && i != 0)
{
if (isProgressAsync)
{
await OutputActionAsync?.Invoke("|\n");
await OutputActionAsync?.Invoke($"{RowLine}\n");
}
else
{
OutputAction?.Invoke("|\n");
OutputAction?.Invoke($"{RowLine}\n");
}
}
if (isProgressAsync)
{
await OutputActionAsync?.Invoke($"| {Convert.ToInt16(output[i])} ");
}
else
{
OutputAction?.Invoke($"| {Convert.ToInt16(output[i])} ");
}
WritingProgess = (double)(i + 1) / writingLenth;
}
Finalize?.Invoke();
}
public OutputAction <TElement> FromFunction <TElement>(Func <TElement> action)
{
return(OutputAction <TElement> .FromFunction(action, schedulerProvider.MainScheduler));
}
public DiagnosticPipeline(
IHealthReporter healthReporter,
IReadOnlyCollection <IObservable <EventData> > inputs,
IReadOnlyCollection <IFilter> globalFilters,
IReadOnlyCollection <EventSink> sinks,
DiagnosticPipelineConfiguration pipelineConfiguration = null,
bool disposeDependencies = false,
TaskScheduler taskScheduler = null)
{
Requires.NotNull(healthReporter, nameof(healthReporter));
Requires.NotNull(inputs, nameof(inputs));
Requires.Argument(inputs.Count > 0, nameof(inputs), "There must be at least one input");
Requires.NotNull(sinks, nameof(sinks));
Requires.Argument(sinks.Count > 0, nameof(sinks), "There must be at least one sink");
this.batcherTimerDisposalLock = new object();
this.pipelineConfiguration = pipelineConfiguration ?? new DiagnosticPipelineConfiguration();
taskScheduler = taskScheduler ?? TaskScheduler.Current;
// An estimatie how many batches of events to allow inside the pipeline.
// We want to be able to process full buffer of events, but also have enough batches in play in case of high concurrency.
int MaxNumberOfBatchesInProgress = Math.Max(
5 * this.pipelineConfiguration.MaxConcurrency,
this.pipelineConfiguration.PipelineBufferSize / this.pipelineConfiguration.MaxEventBatchSize);
this.Inputs = inputs;
this.Sinks = sinks;
// Just play nice and make sure there is always something to enumerate on
this.GlobalFilters = globalFilters ?? new IFilter[0];
this.HealthReporter = healthReporter;
this.cancellationTokenSource = new CancellationTokenSource();
var propagateCompletion = new DataflowLinkOptions()
{
PropagateCompletion = true
};
// One disposable for each input subscription.
this.inputSubscriptions = new List <IDisposable>(inputs.Count);
var inputBuffer = new BufferBlock <EventData>(
new DataflowBlockOptions()
{
BoundedCapacity = this.pipelineConfiguration.PipelineBufferSize,
CancellationToken = this.cancellationTokenSource.Token,
TaskScheduler = taskScheduler
});
this.pipelineHead = inputBuffer;
var batcher = new BatchBlock <EventData>(
this.pipelineConfiguration.MaxEventBatchSize,
new GroupingDataflowBlockOptions()
{
BoundedCapacity = this.pipelineConfiguration.PipelineBufferSize,
CancellationToken = this.cancellationTokenSource.Token,
TaskScheduler = taskScheduler
}
);
inputBuffer.LinkTo(batcher, propagateCompletion);
ISourceBlock <EventData[]> sinkSource;
FilterAction filterTransform;
if (this.GlobalFilters.Count > 0)
{
filterTransform = new FilterAction(
this.GlobalFilters,
this.cancellationTokenSource.Token,
MaxNumberOfBatchesInProgress,
this.pipelineConfiguration.MaxConcurrency,
healthReporter,
taskScheduler);
var globalFiltersBlock = filterTransform.GetFilterBlock();
batcher.LinkTo(globalFiltersBlock, propagateCompletion);
sinkSource = globalFiltersBlock;
}
else
{
sinkSource = batcher;
}
bool usingBroadcastBlock = sinks.Count > 1;
if (usingBroadcastBlock)
{
var broadcaster = new BroadcastBlock <EventData[]>(
(events) => events?.Select((e) => e.DeepClone()).ToArray(),
new DataflowBlockOptions()
{
BoundedCapacity = MaxNumberOfBatchesInProgress,
CancellationToken = this.cancellationTokenSource.Token,
TaskScheduler = taskScheduler
});
sinkSource.LinkTo(broadcaster, propagateCompletion);
sinkSource = broadcaster;
}
this.outputCompletionTasks = new List <Task>(sinks.Count);
foreach (var sink in sinks)
{
ISourceBlock <EventData[]> outputSource = sinkSource;
if (sink.Filters != null && sink.Filters.Count > 0)
{
filterTransform = new FilterAction(
sink.Filters,
this.cancellationTokenSource.Token,
MaxNumberOfBatchesInProgress,
this.pipelineConfiguration.MaxConcurrency,
healthReporter,
taskScheduler);
var filterBlock = filterTransform.GetFilterBlock();
if (usingBroadcastBlock)
{
var lossReportingPropagator = new LossReportingPropagatorBlock <EventData[]>(this.HealthReporter);
sinkSource.LinkTo(lossReportingPropagator, propagateCompletion);
lossReportingPropagator.LinkTo(filterBlock, propagateCompletion);
}
else
{
sinkSource.LinkTo(filterBlock, propagateCompletion);
}
outputSource = filterBlock;
}
else if (usingBroadcastBlock)
{
var lossReportingPropagator = new LossReportingPropagatorBlock <EventData[]>(this.HealthReporter);
sinkSource.LinkTo(lossReportingPropagator, propagateCompletion);
outputSource = lossReportingPropagator;
}
OutputAction outputAction = new OutputAction(
sink.Output,
this.cancellationTokenSource.Token,
MaxNumberOfBatchesInProgress,
this.pipelineConfiguration.MaxConcurrency,
healthReporter,
taskScheduler);
var outputBlock = outputAction.GetOutputBlock();
outputSource.LinkTo(outputBlock, propagateCompletion);
this.outputCompletionTasks.Add(outputBlock.Completion);
}
IObserver <EventData> inputBufferObserver = new TargetBlockObserver <EventData>(inputBuffer, this.HealthReporter);
foreach (var input in inputs)
{
this.inputSubscriptions.Add(input.Subscribe(inputBufferObserver));
}
this.disposed = false;
this.disposeDependencies = disposeDependencies;
this.batcherTimer = new Timer(
(_) => {
try
{
lock (this.batcherTimerDisposalLock)
{
if (!this.disposed)
{
batcher.TriggerBatch();
this.batcherTimer.Change(dueTime: TimeSpan.FromMilliseconds(this.pipelineConfiguration.MaxBatchDelayMsec), period: Timeout.InfiniteTimeSpan);
}
}
}
catch { }
},
state: null,
dueTime: TimeSpan.FromMilliseconds(this.pipelineConfiguration.MaxBatchDelayMsec),
period: Timeout.InfiniteTimeSpan);
}
public PushModelOutputAction(OutputAction child = null)
: base(child)
{
}
private ActionsControllerPressManager AddOutputActionHandler(StateChangeHandlerDelegate <Vector2ActionChangeEvent> handler, OutputAction outputAction)
{
AddHandler(handler,
Vector2AxisActionChangeComparator,
ActionsController.Vector2ActionChange[outputAction]);
return(this);
}
public void Execute()
{
Debug.WriteLine("Execution start");
// init registers
int a = 0; // accumulator
int c = 0; // code pointer
int d = 0; // data pointer
while (true)
{
int instruction = Memory[c];
if (instruction > 32 && instruction < 127) // [33-126]
{
int opCodeEncrypted = (c + instruction - 33) % 94;
char opCode = DecryptionTable[opCodeEncrypted];
Debug.WriteLine($"Opcode:{opCodeEncrypted} => {opCode}");
// Perform instruction
switch (opCode)
{
case 'j': // 40: mov d,[d]
Debug.WriteLine("Instruction: MOV");
d = Memory[d];
break;
case 'i': // 4: jmp[d]
Debug.WriteLine("Instruction: JMP");
c = Memory[d];
break;
case '*': // 39: rotr [d] | mov a,d
Debug.WriteLine("Instruction: ROTR");
Memory[d] = Memory[d] / 3 + Memory[d] % 3 * 19683;
a = Memory[d];
break;
case 'p': // 62: crazy [d],a | mov a,[d]
Debug.WriteLine("Instruction: CRAZY");
Memory[d] = Crazy(a, Memory[d]);
a = Memory[d];
break;
case '<': // 5: stdout
Debug.WriteLine("Instruction: STDOUT");
OutputAction?.Invoke((char)(a & 0xFF));
break;
case '/': // 23: stdin
Debug.WriteLine("Instruction: STDIN");
char?input = InputFunc?.Invoke();
if (input == null)
{
Debug.WriteLine("Null input");
}
else
{
if (input.Value == '\n')
{
a = 10;
}
//else if (input == EOF) // TODO
// a = int.MaxValue;
else
{
a = input.Value;
}
}
break;
case 'v': // 81: end
Debug.WriteLine("Instruction: END OF PROGRAM");
return;
case 'o': // 68: nop
Debug.WriteLine("Instruction: NOP");
break;
default:
Debug.WriteLine("Instruction: INVALID");
break;
}
// Encrypt instruction
Memory[c] = EncryptionTable[Memory[c] - 33];
// Advance c and d
if (c == MaxValue)
{
c = 0;
}
else
{
c++;
}
if (d == MaxValue)
{
d = 0;
}
else
{
d++;
}
}
else
{
Debug.WriteLine($"Skipping invalid instruction {instruction}");
}
}
}
public ActionChange(Hand hand, OutputAction action, bool state)
{
this.hand = hand;
this.action = action;
this.state = state;
}
public void Execute()
{
Random random = new Random();
int maxX = Grid.GetLength(1);
int maxY = Grid.GetLength(0);
int x = 0;
int y = 0;
Directions direction = 0;
bool stringMode = false;
bool skip = false;
while (true)
{
// cyclic boundaries
if (x < 0 || y < 0 || x >= maxX || y >= maxY)
{
switch (direction)
{
case Directions.Right:
x = 0;
break;
case Directions.Down:
y = 0;
break;
case Directions.Left:
x = maxX - 1;
break;
case Directions.Up:
y = maxY - 1;
break;
}
}
//
char instruction = Grid[y, x];
Debug.WriteLine($"Instruction at {x},{y} = {instruction} string:{stringMode} skip:{skip}");
// skip or not
if (skip)
{
skip = false; // skip instruction
Debug.WriteLine("BRIDGE OFF: skipping current instruction.");
}
// string mode or not
else if (stringMode)
{
// push instruction as string
if (instruction == '"')
{
Debug.WriteLine("STRING MODE OFF");
stringMode = false;
}
else
{
int operand = instruction;
Debug.WriteLine($"STRING MODE: PUSH {operand}");
Push(operand);
}
}
else
{
switch (instruction)
{
//Push this number on the stack
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
int digit = instruction - 48;
Push(digit);
Debug.WriteLine($"PUSH DIGIT {digit}");
break;
//Addition: Pop a and b, then push a+b
case '+':
//Subtraction: Pop a and b, then push b-a
case '-':
//Multiplication: Pop a and b, then push a*b
case '*':
//Integer division: Pop a and b, then push b/a, rounded towards 0.
case '/':
//Modulo: Pop a and b, then push the remainder of the integer division of b/a.
case '%':
PerformMathOperation(instruction);
break;
//Logical NOT: Pop a value. If the value is zero, push 1; otherwise, push zero.
case '!':
{
int operand = Pop();
int result = operand == 0 ? 1 : 0;
Debug.WriteLine($"NOT({operand})={result}");
Push(result);
}
break;
//Greater than: Pop a and b, then push 1 if b>a, otherwise zero.
case '`':
{
int operand2 = Pop();
int operand1 = Pop();
int result = operand1 > operand2 ? 1 : 0;
Debug.WriteLine($"GREATER({operand1},{operand2})={result}");
Push(result);
}
break;
//Start moving right
case '>':
direction = Directions.Right;
Debug.WriteLine("MOVE RIGHT");
break;
//Start moving left
case '<':
direction = Directions.Left;
Debug.WriteLine("MOVE LEFT");
break;
//Start moving up
case '^':
direction = Directions.Up;
Debug.WriteLine("MOVE UP");
break;
//Start moving down
case 'v':
direction = Directions.Down;
Debug.WriteLine("MOVE DOWN");
break;
//Start moving in a random cardinal direction
case '?':
direction = (Directions)random.Next(4);
Debug.WriteLine($"MOVE RANDOM={direction}");
break;
//Pop a value; move right if value=0, left otherwise
case '_':
{
int operand = Pop();
direction = operand == 0
? Directions.Right
: Directions.Left;
Debug.WriteLine($"CHANGE HORIZONTAL({operand})={direction}");
}
break;
//Pop a value; move down if value=0, up otherwise
case '|':
{
int operand = Pop();
direction = operand == 0
? Directions.Down
: Directions.Up;
Debug.WriteLine($"CHANGE VERTICAL({operand})={direction}");
}
break;
//Start string mode: push each character's ASCII value all the way up to the next "
case '\"':
stringMode = true;
Debug.WriteLine("STRING MODE ON");
break;
//Duplicate value on top of the stack
case ':':
{
int operand = Pop();
Push(operand);
Push(operand);
Debug.WriteLine($"DUP({operand})");
}
break;
//Swap two values on top of the stack
case '\\':
{
int operand2 = Pop();
int operand1 = Pop();
Push(operand2);
Push(operand1);
Debug.WriteLine($"SWAP({operand1},{operand2})");
}
break;
//Pop value from the stack and discard it
case '$':
{
Pop(); // pop and discard
Debug.WriteLine("POP");
}
break;
//Pop value and output as an integer followed by a space
case '.':
{
int operand = Pop();
Debug.WriteLine($"OUT NUMBER({operand})");
OutputAction?.Invoke(operand.ToString());
}
break;
//Pop value and output as ASCII character
case ',':
{
int outputAsInt = Pop();
char operand = (char)(outputAsInt % 255);
OutputAction?.Invoke(operand.ToString());
Debug.WriteLine($"OUT CHAR({operand})");
}
break;
//Bridge: Skip next cell
case '#':
skip = true;
Debug.WriteLine("BRIDGE ON: skipping next instruction");
break;
//A "put" call (a way to store a value for later use). Pop y, x, and v, then change the character at (x,y) in the program to the character with ASCII value v
case 'p':
{
int putY = Pop();
int putX = Pop();
int putValue = Pop();
Grid[putY, putX] = (char)putValue;
Debug.WriteLine($"PUT({putX},{putY})={putValue}");
}
break;
//A "get" call (a way to retrieve data in storage). Pop y and x, then push ASCII value of the character at that position in the program
case 'g':
{
int getY = Pop();
int getX = Pop();
int getValue = Grid[getY, getX];
Push(getValue);
Debug.WriteLine($"GET({getX},{getY})={getValue}");
}
break;
//Ask user for a number and push it
case '&':
{
string inputAsString = InputFunc?.Invoke();
if (string.IsNullOrWhiteSpace(inputAsString))
{
Debug.WriteLine("IN NUMBER failed: null or empty input");
}
else
{
int operand;
if (!int.TryParse(inputAsString, out operand))
{
Debug.WriteLine($"IN NUMBER failed: invalid input {inputAsString}");
}
else
{
Push(operand);
Debug.WriteLine($"IN NUMBER({operand})");
}
}
}
break;
//Ask user for a character and push its ASCII value
case '~':
{
string inputAsString = InputFunc?.Invoke();
if (string.IsNullOrEmpty(inputAsString))
{
Debug.WriteLine("IN CHAR failed: null or empty input");
}
else
{
int inputChar = inputAsString[0] % 255;
Debug.WriteLine($"IN CHAR({inputChar})");
Push(inputChar);
}
}
break;
//End program
case '@':
Debug.WriteLine("END OF PROGRAM");
return;
//NOP
case ' ':
Debug.WriteLine("NOP");
break;
//Unknown instruction
default:
Debug.WriteLine($"Unknown instruction:{instruction}");
break;
}
}
// Move instruction pointers according to direction
MoveDirectionUntilInstructionFound(direction, stringMode, ref x, ref y);
}
}
public Vector2ActionChangeEvent(Hand hand, OutputAction action, Vector2 state)
{
this.hand = hand;
this.action = action;
this.state = state;
}
public SqlserverActionOutputAction(WorkflowStoreSql store, OutputAction child = null)
: base(child)
{
this._store = store;
}
string[] GetBindingNames(OutputAction outputAction, NameType nameType) => ActionsController.GetBindingNames(ActionsControllerBindingsLoader.CurrentBindingsController, outputAction, nameType);
public PushLogOutputAction(OutputAction child = null)
: base(child)
{
}
private void InputGUI()
{
Vector2 delta = current.delta;
switch (current.type)
{
case EventType.MouseDown:
GraphEditor.mouse_down_position = GraphEditor.mouse_position;
switch (current.button)
{
case 0:
if (current.alt)
{
break;
}
if (GraphEditor.hover_node)
{
if (current.clickCount >= 2)
{
if (GraphEditor.hover_node is MacroNode)
{
SetGraphAsset(((MacroNode)GraphEditor.hover_node).reference);
current.Use();
return;
}
else
{
EditorUtils.OpenScriptByType(GraphEditor.hover_node.type);
current.Use();
}
}
if (GraphEditor.hover_port)
{
if (current.control)
{
if (GraphEditor.hover_port is OutputAction)
{
UndoManager.RecordObject(GraphEditor.asset, string.Format("{0} Add Branch", GraphEditor.asset.name));
set_dirty = true;
QuickPlugPort(GraphEditor.hover_port, AddNode <Branch>(GraphEditor.mouse_position / GraphEditor.zoom - GraphEditor.scroll + new Vector2(60.0f, 0.0f)));
}
}
else
{
if (current.shift)
{
GraphEditor.can_drag_node = false;
GraphEditor.can_drag_port = false;
if (GraphEditor.hover_port is IPlug)
{
UndoManager.RecordObject(GraphEditor.asset, string.Format("{0} > {1}: {2} Unplug", GraphEditor.asset.name, GraphEditor.hover_node.name, GraphEditor.hover_port.name));
set_dirty = true;
((IPlug)GraphEditor.hover_port).Unplug();
}
current.Use();
}
else
{
GraphEditor.can_drag_node = false;
GraphEditor.can_drag_port = true;
SelectOnlyNode(GraphEditor.hover_node);
current.Use();
}
}
}
else
{
if (current.shift)
{
if (GraphEditor.hover_node.is_selected)
{
GraphEditor.can_drag_node = false;
DeselectNode(GraphEditor.hover_node);
current.Use();
}
else
{
GraphEditor.can_drag_node = true;
SelectNode(GraphEditor.hover_node);
current.Use();
}
}
else
{
if (GraphEditor.hover_node.is_selected)
{
GraphEditor.can_drag_node = true;
}
else
{
GraphEditor.can_drag_node = true;
SelectOnlyNode(GraphEditor.hover_node);
current.Use();
}
}
}
}
else if (editable_area.Contains(GraphEditor.mouse_position))
{
GraphEditor.can_select = true;
}
break;
case 1:
break;
case 2:
break;
}
break;
case EventType.MouseUp:
switch (current.button)
{
case 0:
if (GraphEditor.can_select && GraphEditor.is_select)
{
Rect select_box_in_scroll = new Rect(select_box.position / target_zoom, select_box.size / target_zoom);
List <Node> nodes = GraphEditor.graph.nodes.Where((n) => select_box_in_scroll.Overlaps(n.nodeRect)).ToList();
if (current.shift)
{
foreach (Node node in nodes)
{
if (node.is_selected)
{
DeselectNode(node);
}
else
{
SelectNode(node);
}
}
current.Use();
}
else
{
ClearSelection();
SelectNodes(nodes);
current.Use();
}
}
else
{
if (GraphEditor.hover_node)
{
if (GraphEditor.is_drag)
{
if (GraphEditor.drag_port)
{
if (GraphEditor.hover_port)
{
PlugPort(GraphEditor.drag_port, GraphEditor.hover_port);
}
else
{
QuickPlugPort(GraphEditor.drag_port, GraphEditor.hover_node);
}
current.Use();
}
}
else
{
if (!current.shift)
{
if (GraphEditor.selection.Count > 1)
{
SelectOnlyNode(GraphEditor.hover_node);
current.Use();
}
}
}
}
else if (!GraphEditor.is_scrolling)
{
ClearSelection();
}
if (GraphEditor.drag_port && !GraphEditor.hover_node)
{
InputAction in_act = GraphEditor.drag_port as InputAction;
OutputAction out_act = GraphEditor.drag_port as OutputAction;
IInputValue in_value = GraphEditor.drag_port as IInputValue;
IOutputValue out_value = GraphEditor.drag_port as IOutputValue;
if (in_act != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:in void");
}
else if (out_act != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:out void");
}
else if (in_value != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:out " + in_value.valueType.GetTypeName(false, true));
}
else if (out_value != null)
{
GraphEditor.waiting_for_new_node = true;
AdvancedSearchWindow.Init(GraphEditor.mouse_position, "#tag:in " + out_value.valueType.GetTypeName(false, true));
}
}
}
GraphEditor.can_select = false;
GraphEditor.is_select = false;
GraphEditor.is_scrolling = false;
GraphEditor.hover_node = null;
GraphEditor.drag_node = null;
if (!GraphEditor.waiting_for_new_node)
{
GraphEditor.is_drag = false;
GraphEditor.drag_port = null;
GraphEditor.can_drag_port = false;
}
GraphEditor.can_drag_node = false;
break;
case 1:
if (!GraphEditor.is_drag)
{
AdvancedSearchWindow.Init(GraphEditor.mouse_position);
current.Use();
}
GraphEditor.is_drag = false;
break;
case 2:
break;
}
break;
case EventType.MouseDrag:
switch (current.button)
{
case 0:
if (current.alt)
{
GraphEditor.is_drag = true;
GraphEditor.is_scrolling = true;
GraphEditor.scroll += delta;
break;
}
if (!GraphEditor.is_drag)
{
if (GraphEditor.can_drag_port && GraphEditor.hover_port)
{
GraphEditor.is_drag = true;
GraphEditor.can_drag_node = false;
GraphEditor.drag_port = GraphEditor.hover_port;
}
if (GraphEditor.can_drag_node && GraphEditor.hover_node)
{
GraphEditor.is_drag = true;
GraphEditor.can_drag_port = false;
GraphEditor.drag_node = GraphEditor.hover_node;
}
}
// ...
if (GraphEditor.is_drag)
{
if (GraphEditor.drag_node)
{
foreach (Node node in GraphEditor.selection)
{
node.position += delta;
}
}
}
else
{
if (GraphEditor.can_select)
{
GraphEditor.is_select = true;
}
}
break;
case 1:
GraphEditor.is_drag = true;
GraphEditor.is_scrolling = true;
GraphEditor.scroll += delta;
break;
case 2:
GraphEditor.is_drag = true;
GraphEditor.is_scrolling = true;
GraphEditor.scroll += delta;
break;
}
break;
case EventType.ScrollWheel:
if (!GraphEditor.is_drag)
{
float zoom_delta = 0.1f;
zoom_delta = current.delta.y < 0.0f ? zoom_delta : -zoom_delta;
target_zoom += zoom_delta;
target_zoom = Mathf.Clamp(target_zoom, 0.2f, 1.0f);
}
break;
case EventType.ValidateCommand:
switch (Event.current.commandName)
{
case ("Delete"):
DeleteSelectedNodes();
current.Use();
break;
case ("Duplicate"):
DuplicateSelectedNodes();
current.Use();
break;
case ("SelectAll"):
if (GraphEditor.selection.Count == GraphEditor.graph.nodeCount)
{
ClearSelection();
current.Use();
}
else
{
SelectNodes(GraphEditor.graph.nodes);
current.Use();
}
break;
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (DragAndDrop.objectReferences.Length > 0)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (current.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
GenericMenu generic_menu = new GenericMenu();
Type type;
string type_name;
foreach (UnityObject drag_obj in DragAndDrop.objectReferences)
{
if (drag_obj == null)
{
continue;
}
if (drag_obj is GraphAsset)
{
GraphAsset m_asset = (GraphAsset)drag_obj;
if (m_asset)
{
generic_menu.AddItem(new GUIContent(string.Format("Add {0} as Macro", m_asset.title.IsNullOrEmpty() ? m_asset.name : m_asset.title)), false, (obj) => {
AddMacro(m_asset, (Vector2)obj);
}, GraphEditor.mouse_position - GraphEditor.scroll);
}
}
else if (drag_obj is MonoScript)
{
MonoScript script = (MonoScript)drag_obj;
if (script)
{
type = script.GetClass();
type_name = type.GetTypeName();
generic_menu.AddItem(new GUIContent(string.Format("{0}/Expose {0} members", type_name)), false, (obj) => {
AddCustomNode <ReflectedObjectNode>((Vector2)obj, true, type);
}, GraphEditor.mouse_position - GraphEditor.scroll);
generic_menu.AddSeparator(string.Format("{0}/", type_name));
AddTypeMethodsToMenu(generic_menu, type, type_name);
if (type.IsSubclassOf(typeof(Node)) && !type.IsAbstract && !type.IsGenericType)
{
generic_menu.AddItem(new GUIContent(string.Format("Add {0} as Node", type_name)), false, (obj) => {
AddNode(type, (Vector2)obj);
}, GraphEditor.mouse_position - GraphEditor.scroll);
}
}
}
if (drag_obj is GraphAsset || drag_obj is MonoScript)
{
generic_menu.AddSeparator("");
}
type = drag_obj.GetType();
type_name = type.GetTypeName();
generic_menu.AddItem(new GUIContent(string.Format("Expose {0} members", type_name)), false, (obj) => {
AddCustomNode <ReflectedObjectNode>((Vector2)obj, true, type);
}, GraphEditor.mouse_position - GraphEditor.scroll);
AddTypeMethodsToMenu(generic_menu, type, type_name);
}
DragAndDrop.PrepareStartDrag();
generic_menu.ShowAsContext();
}
}
break;
case (EventType.KeyDown):
switch (current.keyCode)
{
case KeyCode.Space:
if (!current.control)
{
AdvancedSearchWindow.Init(position.size / 2.0f);
current.Use();
}
break;
case KeyCode.Delete:
DeleteSelectedNodes();
current.Use();
break;
case KeyCode.Home:
target_zoom = 1.0f;
GraphEditor.scroll = Vector2.zero;
current.Use();
break;
case KeyCode.PageDown:
GraphEditor.scroll -= new Vector2(0.0f, position.height);
current.Use();
break;
case KeyCode.PageUp:
GraphEditor.scroll += new Vector2(0.0f, position.height);
current.Use();
break;
}
break;
}
}
/// <summary>
/// Resolves the output actions for the given output.
/// </summary>
/// <param name="loader">The loader containing the map file definition.</param>
/// <param name="output">The output to resolve actions for.</param>
/// <returns>An output's actions collection.</returns>
private static IEnumerable<OutputAction> ResolveOutputActions(MapLoader loader, XmlElement output)
{
Dictionary<string, OutputAction> actions = new Dictionary<string, OutputAction>();
foreach (XmlElement element in loader.Map.SelectNodes("jspack/outputAction[@global='true']"))
{
string name = element.Attributes["name"].Value;
actions[name] = new OutputAction(name, element.Attributes["executable"].Value, element.Attributes["arguments"].Value);
}
foreach (XmlElement element in output.SelectNodes("action"))
{
string name = element.Attributes["name"].Value;
string args = element.Attributes["arguments"].Value;
if (actions.ContainsKey(name))
{
if (!String.IsNullOrEmpty(args))
{
actions[name].Arguments = args;
}
}
else
{
XmlElement action = loader.Map.SelectSingleNode("jspack/outputAction[@name='" + name + "']") as XmlElement;
if (action != null)
{
if (String.IsNullOrEmpty(args))
{
args = action.Attributes["arguments"].Value;
}
actions[name] = new OutputAction(name, action.Attributes["executable"].Value, args);
}
}
}
return (from kvp in actions
select kvp.Value).ToArray();
}
public DiagnosticPipeline(
IHealthReporter healthReporter,
IReadOnlyCollection <IObservable <EventData> > inputs,
IReadOnlyCollection <IFilter> globalFilters,
IReadOnlyCollection <EventSink> sinks,
DiagnosticPipelineConfiguration pipelineConfiguration = null,
bool disposeDependencies = false)
{
Requires.NotNull(healthReporter, nameof(healthReporter));
Requires.NotNull(inputs, nameof(inputs));
Requires.Argument(inputs.Count > 0, nameof(inputs), "There must be at least one input");
Requires.NotNull(sinks, nameof(sinks));
Requires.Argument(sinks.Count > 0, nameof(sinks), "There must be at least one sink");
this.pipelineConfiguration = pipelineConfiguration ?? new DiagnosticPipelineConfiguration();
this.Inputs = inputs;
this.Sinks = sinks;
// Just play nice and make sure there is always something to enumerate on
this.GlobalFilters = globalFilters ?? new IFilter[0];
this.HealthReporter = healthReporter;
this.cancellationTokenSource = new CancellationTokenSource();
var propagateCompletion = new DataflowLinkOptions()
{
PropagateCompletion = true
};
this.pipelineDisposables = new List <IDisposable>();
var inputBuffer = new BufferBlock <EventData>(
new DataflowBlockOptions()
{
BoundedCapacity = this.pipelineConfiguration.PipelineBufferSize,
CancellationToken = this.cancellationTokenSource.Token
});
this.pipelineHead = inputBuffer;
var batcher = new BatchBlock <EventData>(
this.pipelineConfiguration.MaxEventBatchSize,
new GroupingDataflowBlockOptions()
{
BoundedCapacity = this.pipelineConfiguration.MaxEventBatchSize,
CancellationToken = this.cancellationTokenSource.Token
}
);
this.pipelineDisposables.Add(inputBuffer.LinkTo(batcher, propagateCompletion));
this.pipelineDisposables.Add(new Timer(
(unused) => batcher.TriggerBatch(),
state: null,
dueTime: TimeSpan.FromMilliseconds(this.pipelineConfiguration.MaxBatchDelayMsec),
period: TimeSpan.FromMilliseconds(this.pipelineConfiguration.MaxBatchDelayMsec)));
ISourceBlock <EventData[]> sinkSource;
FilterAction filterTransform;
if (this.GlobalFilters.Count > 0)
{
filterTransform = new FilterAction(
this.GlobalFilters,
this.cancellationTokenSource.Token,
this.pipelineConfiguration.MaxEventBatchSize,
this.pipelineConfiguration.MaxConcurrency,
healthReporter);
var globalFiltersBlock = filterTransform.GetFilterBlock();
this.pipelineDisposables.Add(batcher.LinkTo(globalFiltersBlock, propagateCompletion));
sinkSource = globalFiltersBlock;
}
else
{
sinkSource = batcher;
}
if (sinks.Count > 1)
{
var broadcaster = new BroadcastBlock <EventData[]>(
(events) => events?.Select((e) => e.DeepClone()).ToArray(),
new DataflowBlockOptions()
{
BoundedCapacity = this.pipelineConfiguration.MaxEventBatchSize,
CancellationToken = this.cancellationTokenSource.Token
});
this.pipelineDisposables.Add(sinkSource.LinkTo(broadcaster, propagateCompletion));
sinkSource = broadcaster;
}
foreach (var sink in sinks)
{
ISourceBlock <EventData[]> outputSource = sinkSource;
if (sink.Filters != null && sink.Filters.Count > 0)
{
filterTransform = new FilterAction(
sink.Filters,
this.cancellationTokenSource.Token,
this.pipelineConfiguration.MaxEventBatchSize,
this.pipelineConfiguration.MaxConcurrency,
healthReporter);
var filterBlock = filterTransform.GetFilterBlock();
this.pipelineDisposables.Add(sinkSource.LinkTo(filterBlock, propagateCompletion));
outputSource = filterBlock;
}
OutputAction outputAction = new OutputAction(
sink.Output,
this.cancellationTokenSource.Token,
this.pipelineConfiguration.MaxEventBatchSize,
this.pipelineConfiguration.MaxConcurrency,
healthReporter);
ActionBlock <EventData[]> outputBlock = outputAction.GetOutputBlock();
this.pipelineDisposables.Add(outputSource.LinkTo(outputBlock, propagateCompletion));
}
IObserver <EventData> inputBufferObserver = new TargetBlockObserver <EventData>(inputBuffer, this.HealthReporter);
this.inputSubscriptions = new List <IDisposable>(inputs.Count);
foreach (var input in inputs)
{
this.inputSubscriptions.Add(input.Subscribe(inputBufferObserver));
}
this.disposed = false;
this.disposeDependencies = disposeDependencies;
}
public OutputAction <TElement> FromAsync <TElement>(Func <Task <TElement> > asyncAction, IObservable <bool> enabledIf = null)
{
return(OutputAction <TElement> .FromAsync(asyncAction, schedulerProvider.MainScheduler, enabledIf));
}
private void GenerateAgent()
{
SetUpAgent();
PortfolioProcess portfolioProcess = new PortfolioProcess(portfolioLayoutPanel, TotalEquityLabel, 100000);
portfolioProcess.Name = "Portfolio";
agent.BrainProcessList.Add(portfolioProcess);
portfolioProcess.ActiveOnStartup = true;
MyDialogueProcess mainDialogue = new MyDialogueProcess();
mainDialogue.Name = "MainDialogue";
agent.BrainProcessList.Add(mainDialogue);
mainDialogue.ActiveOnStartup = true;
startButton.Enabled = true;
//Main Item 1
InteractionItem mainDialogueItem1 = new InteractionItem();
mainDialogueItem1.Name = "MainDialogueItem1";
ResponseAction mainItem1ToItem2 = new ResponseAction(); //Search for stock path
mainItem1ToItem2.InputList.Add("Search");
mainItem1ToItem2.OutputList.Add("Which stock would you like to search for?");
mainItem1ToItem2.TargetDialogueItemName = "MainDialogueItem2";
mainDialogueItem1.ActionList.Add(mainItem1ToItem2);
ResponseAction mainItem1ToPortfolioDialogue = new ResponseAction(); //Modify portfolio path
mainItem1ToPortfolioDialogue.InputList.Add("Portfolio");
mainItem1ToPortfolioDialogue.TargetDialogueItemName = "ModifyPortfolioDialogueItem1";
mainItem1ToPortfolioDialogue.BrainProcessToDeactivate = "MainDialogue";
mainItem1ToPortfolioDialogue.BrainProcessToActivate = "ModifyPortfolioDialogue";
mainDialogueItem1.ActionList.Add(mainItem1ToPortfolioDialogue);
mainDialogue.ItemList.Add(mainDialogueItem1);
//TODO: change name readAction
InteractionItem mainDialogueItem2 = new InteractionItem();
mainDialogueItem2.Name = "MainDialogueItem2";
QueryIDAAction readAction2 = new QueryIDAAction();
readAction2.InputList.AddRange(DialogueInputStrings.getStockNameList());
readAction2.InputList.AddRange(DialogueInputStrings.getStockTickerInputs());
readAction2.TargetDialogueItemName = "MainDialogueItem3";
mainDialogueItem2.ActionList.Add(readAction2);
mainDialogue.ItemList.Add(mainDialogueItem2);
//Main Item 3 : Buy/sell or search for another stock
InteractionItem mainDialogueItem3 = new InteractionItem();
mainDialogueItem3.Name = "MainDialogueItem3";
ResponseAction mainItem3ToItem2 = new ResponseAction(); //search another stock path
mainItem3ToItem2.InputList.Add("Search");
mainItem3ToItem2.OutputList.Add("Which stock would you like to search for?");
mainItem3ToItem2.TargetDialogueItemName = "MainDialogueItem2";
mainDialogueItem3.ActionList.Add(mainItem3ToItem2);
ResponseAction mainItem3ToGoLongDialogueAction = new ResponseAction(); //Buy stock path
mainItem3ToGoLongDialogueAction.InputList.Add("Buy");
mainItem3ToGoLongDialogueAction.BrainProcessToDeactivate = "MainDialogue";
mainItem3ToGoLongDialogueAction.BrainProcessToActivate = "GoLongDialogue";
mainDialogueItem3.ActionList.Add(mainItem3ToGoLongDialogueAction);
ResponseAction mainItem3TogoShortDialogueAction = new ResponseAction(); //Skiing path
mainItem3TogoShortDialogueAction.InputList.Add("Sell");
mainItem3TogoShortDialogueAction.BrainProcessToDeactivate = "MainDialogue";
mainItem3TogoShortDialogueAction.BrainProcessToActivate = "GoShortDialogue";
mainDialogueItem3.ActionList.Add(mainItem3TogoShortDialogueAction);
mainDialogue.ItemList.Add(mainDialogueItem3);
/*
* Main Dialogue Process end
*/
/*
* Modify Portfolio Dialogue Process start
*/
MyDialogueProcess modifyPortfolioDialogue = new MyDialogueProcess();
modifyPortfolioDialogue.Name = "ModifyPortfolioDialogue";
agent.BrainProcessList.Add(modifyPortfolioDialogue);
modifyPortfolioDialogue.ActiveOnStartup = false;
//Modify Portfolio Item1 :
CheckEmptyPortfolioItem modifyPortfolioDialogueItem1 = new CheckEmptyPortfolioItem();
modifyPortfolioDialogueItem1.Name = "ModifyPortfolioDialogueItem1";
OutputAction modifyPortfolioItem1ToMainDialogue = new OutputAction(); //There is no portfolio path
modifyPortfolioItem1ToMainDialogue.InputList.Add("failure");
modifyPortfolioItem1ToMainDialogue.OutputList.Add("Sorry, but your portfolio is empty, you have nothing to modify");
modifyPortfolioItem1ToMainDialogue.TargetDialogueItemName = "MainDialogueItem1";
modifyPortfolioItem1ToMainDialogue.BrainProcessToDeactivate = "ModifyPortfolioDialogue";
modifyPortfolioItem1ToMainDialogue.BrainProcessToActivate = "MainDialogue";
modifyPortfolioDialogueItem1.ActionList.Add(modifyPortfolioItem1ToMainDialogue);
OutputAction modifyPortfolioItem1ToItem2 = new OutputAction(); //modify portfolio path
modifyPortfolioItem1ToItem2.InputList.Add("success");
modifyPortfolioItem1ToItem2.TargetDialogueItemName = "ModifyPortfolioDialogueItem2";
modifyPortfolioDialogueItem1.ActionList.Add(modifyPortfolioItem1ToItem2);
modifyPortfolioDialogue.ItemList.Add(modifyPortfolioDialogueItem1);
//Modify Portfolio Item2 : Which id to exit question
InteractionItem modifyPortfolioDialogueItem2 = new InteractionItem();
modifyPortfolioDialogueItem2.Name = "ModifyPortfolioDialogueItem2";
modifyPortfolioDialogueItem2.MillisecondDelay = 500;
OutputAction modifyPortfolioItem2ToItem3 = new OutputAction();
modifyPortfolioItem2ToItem3.OutputList.Add("Enter the ID of the position you want to exit");
modifyPortfolioItem2ToItem3.TargetDialogueItemName = "ModifyPortfolioDialogueItem3";
modifyPortfolioDialogueItem2.ActionList.Add(modifyPortfolioItem2ToItem3);
modifyPortfolioDialogue.ItemList.Add(modifyPortfolioDialogueItem2);
//Modify Portfolio Item3 : which id to exit answer
ExitOrderItem modifyPortfolioDialogueItem3 = new ExitOrderItem();
modifyPortfolioDialogueItem3.Name = "ModifyPortfolioDialogueItem3";
modifyPortfolioDialogueItem3.MillisecondDelay = 1000;
ResponseAction modifyPortfolioItem3ToItem4 = new ResponseAction(); //Exited position path
modifyPortfolioItem3ToItem4.InputList.Add("success");
modifyPortfolioItem3ToItem4.OutputList.Add("Position exited successfully, do you wish to exit another position?");
modifyPortfolioItem3ToItem4.TargetDialogueItemName = "ModifyPortfolioDialogueItem4";
modifyPortfolioDialogueItem3.ActionList.Add(modifyPortfolioItem3ToItem4);
ResponseAction modifyPortfolioItem3ToItem2 = new ResponseAction(); //No ID path
modifyPortfolioItem3ToItem2.InputList.Add("failure");
modifyPortfolioItem3ToItem2.OutputList.Add("The ID doesn't exist, try again.");
modifyPortfolioItem3ToItem2.TargetDialogueItemName = "ModifyPortfolioDialogueItem2";
modifyPortfolioDialogueItem3.ActionList.Add(modifyPortfolioItem3ToItem2);
modifyPortfolioDialogue.ItemList.Add(modifyPortfolioDialogueItem3);
//Modify Portfolio Item4 : Exit another one answer
InteractionItem modifyPortfolioDialogueItem4 = new InteractionItem();
modifyPortfolioDialogueItem4.Name = "ModifyPortfolioDialogueItem4";
modifyPortfolioDialogueItem4.MillisecondDelay = 500;
ResponseAction modifyPortfolioItem4ToMainDialogue = new ResponseAction(); //dont set a stop path
modifyPortfolioItem4ToMainDialogue.InputList.Add("no"); //TODO Change to negative answer list
modifyPortfolioItem4ToMainDialogue.OutputList.Add("Okay, have a nice day!");
modifyPortfolioItem4ToMainDialogue.TargetDialogueItemName = "MainDialogueItem1";
modifyPortfolioItem4ToMainDialogue.BrainProcessToDeactivate = "ModifyPortfolioDialogue";
modifyPortfolioItem4ToMainDialogue.BrainProcessToActivate = "MainDialogue";
modifyPortfolioDialogueItem4.ActionList.Add(modifyPortfolioItem4ToMainDialogue);
ResponseAction modifyPortfolioItem4ToItem2 = new ResponseAction(); // set a stop path
modifyPortfolioItem4ToItem2.InputList.Add("yes");
modifyPortfolioItem4ToItem2.TargetDialogueItemName = "ModifyPortfolioDialogueItem1";
modifyPortfolioDialogueItem4.ActionList.Add(modifyPortfolioItem4ToItem2);
modifyPortfolioDialogue.ItemList.Add(modifyPortfolioDialogueItem4);
/*
* Modify Portfolio Dialogue Process end
*/
/*
* GoLong Dialogue Process start
*/
MyDialogueProcess goLongDialogue = new MyDialogueProcess();
goLongDialogue.Name = "GoLongDialogue";
agent.BrainProcessList.Add(goLongDialogue);
goLongDialogue.ActiveOnStartup = false;
InteractionItem goLongDialogueItem1 = new InteractionItem();
goLongDialogueItem1.Name = "GoLongDialogueItem1";
goLongDialogueItem1.MillisecondDelay = 500;
OutputAction goLongItem1ToItem2 = new OutputAction();
goLongItem1ToItem2.OutputList.Add("How many stocks would you like to buy?");
goLongItem1ToItem2.TargetDialogueItemName = "GoLongDialogueItem2";
goLongDialogueItem1.ActionList.Add(goLongItem1ToItem2);
goLongDialogue.ItemList.Add(goLongDialogueItem1);
MarketOrderItem goLongDialogueItem2 = new MarketOrderItem(MarketOrderItem.DIRECTION_LONG);
goLongDialogueItem2.Name = "GoLongDialogueItem2";
goLongDialogueItem2.MillisecondDelay = 500;
MarketExecutionAction goLongItem2ToItem3 = new MarketExecutionAction();
goLongItem2ToItem3.InputList.Add("success");
goLongItem2ToItem3.TargetDialogueItemName = "GoLongDialogueItem3";
goLongDialogueItem2.ActionList.Add(goLongItem2ToItem3);
ResponseAction goLongItem2ToItem4 = new ResponseAction();
goLongItem2ToItem4.InputList.Add("failure");
goLongItem2ToItem4.OutputList.Add("You have insufficient funds, try again with a smaller size"); //TODO: Change action name
goLongItem2ToItem4.TargetDialogueItemName = "GoLongDialogueItem1";
goLongDialogueItem2.ActionList.Add(goLongItem2ToItem4);
goLongDialogue.ItemList.Add(goLongDialogueItem2);
//Item3 : set SL or TP question
InteractionItem goLongDialogueItem3 = new InteractionItem();
goLongDialogueItem3.Name = "GoLongDialogueItem3";
goLongDialogueItem3.MillisecondDelay = 2000;
OutputAction goLongItem3ToItem5 = new OutputAction();
goLongItem3ToItem5.OutputList.Add("Would you like to set a Stop Loss?");
goLongItem3ToItem5.TargetDialogueItemName = "GoLongDialogueItem5";
goLongDialogueItem3.ActionList.Add(goLongItem3ToItem5);
goLongDialogue.ItemList.Add(goLongDialogueItem3);
//Item5 : set SL or TP answer
InteractionItem goLongDialogueItem5 = new InteractionItem();
goLongDialogueItem5.Name = "GoLongDialogueItem5";
goLongDialogueItem5.MillisecondDelay = 500;
ResponseAction goLongItem5ToItem9 = new ResponseAction(); //dont set a stop path
goLongItem5ToItem9.InputList.Add("no"); //TODO Change to negative answer list
goLongItem5ToItem9.OutputList.Add("Okay, how about a target profit?");
goLongItem5ToItem9.TargetDialogueItemName = "GoLongDialogueItem9";
goLongDialogueItem5.ActionList.Add(goLongItem5ToItem9);
ResponseAction goLongItem5ToItem6Action = new ResponseAction(); // set a stop path
goLongItem5ToItem6Action.InputList.Add("yes");
goLongItem5ToItem6Action.TargetDialogueItemName = "GoLongDialogueItem6";
goLongDialogueItem5.ActionList.Add(goLongItem5ToItem6Action);
goLongDialogue.ItemList.Add(goLongDialogueItem5);
//Item6: where to set stop question
InteractionItem goLongDialogueItem6 = new InteractionItem();
goLongDialogueItem6.Name = "GoLongDialogueItem6";
goLongDialogueItem6.MillisecondDelay = 500;
OutputAction goLongItem6ToItem7 = new OutputAction();
goLongItem6ToItem7.OutputList.Add("At what level would you like to set your stop loss?");
goLongItem6ToItem7.TargetDialogueItemName = "GoLongDialogueItem7";
goLongDialogueItem6.ActionList.Add(goLongItem6ToItem7);
goLongDialogue.ItemList.Add(goLongDialogueItem6);
//Item7 : where to set stop answer
SLTPOrderItem goLongDialogueItem7 = new SLTPOrderItem(SLTPOrderItem.SET_STOPP_LOSS, MarketOrderItem.DIRECTION_LONG);
goLongDialogueItem7.Name = "GoLongDialogueItem7";
goLongDialogueItem7.MillisecondDelay = 500;
LimitExecutionAction goLongItem7ToItem8 = new LimitExecutionAction();
goLongItem7ToItem8.InputList.Add("success");
goLongItem7ToItem8.TargetDialogueItemName = "GoLongDialogueItem8";
goLongDialogueItem7.ActionList.Add(goLongItem7ToItem8);
ResponseAction goLongItem7ToItem6 = new ResponseAction();
goLongItem7ToItem6.InputList.Add("failure");
goLongItem7ToItem6.OutputList.Add("Your limit was on the wrong side of the market, try again");
goLongItem7ToItem6.TargetDialogueItemName = "GoLongDialogueItem6";
goLongDialogueItem7.ActionList.Add(goLongItem7ToItem6);
goLongDialogue.ItemList.Add(goLongDialogueItem7);
//Item8 : set TP question
InteractionItem goLongDialogueItem8 = new InteractionItem();
goLongDialogueItem8.Name = "GoLongDialogueItem8";
goLongDialogueItem8.MillisecondDelay = 1500;
OutputAction goLongItem8ToItem9 = new OutputAction();
goLongItem8ToItem9.OutputList.Add("Would you also like to set a Target Profit?");
goLongItem8ToItem9.TargetDialogueItemName = "GoLongDialogueItem9";
goLongDialogueItem8.ActionList.Add(goLongItem8ToItem9);
goLongDialogue.ItemList.Add(goLongDialogueItem8);
//Item9 : set TP answer
InteractionItem goLongDialogueItem9 = new InteractionItem();
goLongDialogueItem9.Name = "GoLongDialogueItem9";
goLongDialogueItem9.MillisecondDelay = 500;
ResponseAction goLongItem9ToMainDialogueAction = new ResponseAction(); //dont set a target path
goLongItem9ToMainDialogueAction.InputList.Add("no"); //TODO Change to negative answer list
goLongItem9ToMainDialogueAction.OutputList.Add("Okay, have a nice day");
goLongItem9ToMainDialogueAction.TargetDialogueItemName = "MainDialogueItem1";
goLongItem9ToMainDialogueAction.BrainProcessToDeactivate = "GoLongDialogue";
goLongItem9ToMainDialogueAction.BrainProcessToActivate = "MainDialogue";
goLongDialogueItem9.ActionList.Add(goLongItem9ToMainDialogueAction);
ResponseAction goLongItem9ToItem10Action = new ResponseAction(); // set a target path
goLongItem9ToItem10Action.InputList.Add("yes");
goLongItem9ToItem10Action.TargetDialogueItemName = "GoLongDialogueItem10";
goLongDialogueItem9.ActionList.Add(goLongItem9ToItem10Action);
goLongDialogue.ItemList.Add(goLongDialogueItem9);
//Item10: where to set target question
InteractionItem goLongDialogueItem10 = new InteractionItem();
goLongDialogueItem10.Name = "GoLongDialogueItem10";
goLongDialogueItem10.MillisecondDelay = 500;
OutputAction goLongItem10ToItem11 = new OutputAction();
goLongItem10ToItem11.OutputList.Add("At what level would you like to set your target profit?");
goLongItem10ToItem11.TargetDialogueItemName = "GoLongDialogueItem11";
goLongDialogueItem10.ActionList.Add(goLongItem10ToItem11);
goLongDialogue.ItemList.Add(goLongDialogueItem10);
//Item11 : where to set target answer
SLTPOrderItem goLongDialogueItem11 = new SLTPOrderItem(SLTPOrderItem.SET_TARGET_PROFIT, MarketOrderItem.DIRECTION_LONG);
goLongDialogueItem11.Name = "GoLongDialogueItem11";
goLongDialogueItem11.MillisecondDelay = 500;
LimitExecutionAction goLongItem11ToItem12 = new LimitExecutionAction();
goLongItem11ToItem12.InputList.Add("success");
goLongItem11ToItem12.TargetDialogueItemName = "GoLongDialogueItem12";
goLongDialogueItem11.ActionList.Add(goLongItem11ToItem12);
ResponseAction goLongItem11ToItem10 = new ResponseAction();
goLongItem11ToItem10.InputList.Add("failure");
goLongItem11ToItem10.OutputList.Add("Your limit was on the wrong side of the market, try again");
goLongItem11ToItem10.TargetDialogueItemName = "GoLongDialogueItem10";
goLongDialogueItem11.ActionList.Add(goLongItem11ToItem10);
goLongDialogue.ItemList.Add(goLongDialogueItem11);
//Item12 : Everything done, return to main dialogue
InteractionItem goLongDialogueItem12 = new InteractionItem();
goLongDialogueItem12.Name = "GoLongDialogueItem12";
goLongDialogueItem12.MillisecondDelay = 1500;
OutputAction goLongItem12ToMainDialogue = new OutputAction();
goLongItem12ToMainDialogue.OutputList.Add("All is set, good luck and have a nice day!");
goLongItem12ToMainDialogue.TargetDialogueItemName = "MainDialogueItem1";
goLongItem12ToMainDialogue.BrainProcessToDeactivate = "GoLongDialogue";
goLongItem12ToMainDialogue.BrainProcessToActivate = "MainDialogue";
goLongDialogueItem12.ActionList.Add(goLongItem12ToMainDialogue);
goLongDialogue.ItemList.Add(goLongDialogueItem12);
/*
* GoLong Dialogue Process end
*/
/*
* goShort Dialogue Process start
*/
MyDialogueProcess goShortDialogue = new MyDialogueProcess();
goShortDialogue.Name = "GoShortDialogue";
agent.BrainProcessList.Add(goShortDialogue);
goShortDialogue.ActiveOnStartup = false;
InteractionItem goShortDialogueItem1 = new InteractionItem();
goShortDialogueItem1.Name = "GoShortDialogueItem1";
goShortDialogueItem1.MillisecondDelay = 500;
OutputAction goShortItem1ToItem2 = new OutputAction();
goShortItem1ToItem2.OutputList.Add("How many stocks would you like to sell?");
goShortItem1ToItem2.TargetDialogueItemName = "GoShortDialogueItem2";
goShortDialogueItem1.ActionList.Add(goShortItem1ToItem2);
goShortDialogue.ItemList.Add(goShortDialogueItem1);
MarketOrderItem goShortDialogueItem2 = new MarketOrderItem(MarketOrderItem.DIRECTION_SHORT);
goShortDialogueItem2.Name = "GoShortDialogueItem2";
goShortDialogueItem2.MillisecondDelay = 500;
MarketExecutionAction goShortItem2ToItem3 = new MarketExecutionAction();
goShortItem2ToItem3.InputList.Add("success");
goShortItem2ToItem3.TargetDialogueItemName = "GoShortDialogueItem3";
goShortDialogueItem2.ActionList.Add(goShortItem2ToItem3);
goShortDialogue.ItemList.Add(goShortDialogueItem2);
InteractionItem goShortDialogueItem3 = new InteractionItem();
goShortDialogueItem3.Name = "GoShortDialogueItem3";
goShortDialogueItem3.MillisecondDelay = 2000;
OutputAction goShortItem3ToItem5 = new OutputAction();
goShortItem3ToItem5.OutputList.Add("Would you like to set a Stop Loss?");
goShortItem3ToItem5.TargetDialogueItemName = "GoShortDialogueItem5";
goShortDialogueItem3.ActionList.Add(goShortItem3ToItem5);
goShortDialogue.ItemList.Add(goShortDialogueItem3);
//Item5 : set SL or TP answer
InteractionItem goShortDialogueItem5 = new InteractionItem();
goShortDialogueItem5.Name = "GoShortDialogueItem5";
goShortDialogueItem5.MillisecondDelay = 500;
ResponseAction goShortItem5ToItem9 = new ResponseAction(); //dont set a stop path
goShortItem5ToItem9.InputList.Add("no"); //TODO Change to negative answer list
goShortItem5ToItem9.OutputList.Add("Okay, how about a target profit?");
goShortItem5ToItem9.TargetDialogueItemName = "GoShortDialogueItem9";
goShortDialogueItem5.ActionList.Add(goShortItem5ToItem9);
ResponseAction goShortItem5ToItem6Action = new ResponseAction(); // set a stop path
goShortItem5ToItem6Action.InputList.Add("yes");
goShortItem5ToItem6Action.TargetDialogueItemName = "GoShortDialogueItem6";
goShortDialogueItem5.ActionList.Add(goShortItem5ToItem6Action);
goShortDialogue.ItemList.Add(goShortDialogueItem5);
//Item6: where to set stop question
InteractionItem goShortDialogueItem6 = new InteractionItem();
goShortDialogueItem6.Name = "GoShortDialogueItem6";
goShortDialogueItem6.MillisecondDelay = 500;
OutputAction goShortItem6ToItem7 = new OutputAction();
goShortItem6ToItem7.OutputList.Add("At what level would you like to set your stop loss?");
goShortItem6ToItem7.TargetDialogueItemName = "GoShortDialogueItem7";
goShortDialogueItem6.ActionList.Add(goShortItem6ToItem7);
goShortDialogue.ItemList.Add(goShortDialogueItem6);
//Item7 : where to set stop answer
SLTPOrderItem goShortDialogueItem7 = new SLTPOrderItem(SLTPOrderItem.SET_STOPP_LOSS, MarketOrderItem.DIRECTION_SHORT);
goShortDialogueItem7.Name = "GoShortDialogueItem7";
goShortDialogueItem7.MillisecondDelay = 500;
LimitExecutionAction goShortItem7ToItem8 = new LimitExecutionAction();
goShortItem7ToItem8.InputList.Add("success");
goShortItem7ToItem8.TargetDialogueItemName = "GoShortDialogueItem8";
goShortDialogueItem7.ActionList.Add(goShortItem7ToItem8);
ResponseAction goShortItem7ToItem6 = new ResponseAction();
goShortItem7ToItem6.InputList.Add("failure");
goShortItem7ToItem6.OutputList.Add("Your limit was on the wrong side of the market, try again");
goShortItem7ToItem6.TargetDialogueItemName = "GoShortDialogueItem6";
goShortDialogueItem7.ActionList.Add(goShortItem7ToItem6);
goShortDialogue.ItemList.Add(goShortDialogueItem7);
//Item8 : set TP question
InteractionItem goShortDialogueItem8 = new InteractionItem();
goShortDialogueItem8.Name = "GoShortDialogueItem8";
goShortDialogueItem8.MillisecondDelay = 1500;
OutputAction goShortItem8ToItem9 = new OutputAction();
goShortItem8ToItem9.OutputList.Add("Would you also like to set a Target Profit?");
goShortItem8ToItem9.TargetDialogueItemName = "GoShortDialogueItem9";
goShortDialogueItem8.ActionList.Add(goShortItem8ToItem9);
goShortDialogue.ItemList.Add(goShortDialogueItem8);
//Item9 : set TP answer
InteractionItem goShortDialogueItem9 = new InteractionItem();
goShortDialogueItem9.Name = "GoShortDialogueItem9";
goShortDialogueItem9.MillisecondDelay = 500;
ResponseAction goShortItem9ToMainDialogueAction = new ResponseAction(); //dont set a target path
goShortItem9ToMainDialogueAction.InputList.Add("no"); //TODO Change to negative answer list
goShortItem9ToMainDialogueAction.OutputList.Add("Okay, have a nice day");
goShortItem9ToMainDialogueAction.TargetDialogueItemName = "MainDialogueItem1";
goShortItem9ToMainDialogueAction.BrainProcessToDeactivate = "GoShortDialogue";
goShortItem9ToMainDialogueAction.BrainProcessToActivate = "MainDialogue";
goShortDialogueItem9.ActionList.Add(goShortItem9ToMainDialogueAction);
ResponseAction goShortItem9ToItem10Action = new ResponseAction(); // set a target path
goShortItem9ToItem10Action.InputList.Add("yes");
goShortItem9ToItem10Action.TargetDialogueItemName = "GoShortDialogueItem10";
goShortDialogueItem9.ActionList.Add(goShortItem9ToItem10Action);
goShortDialogue.ItemList.Add(goShortDialogueItem9);
//Item10: where to set target question
InteractionItem goShortDialogueItem10 = new InteractionItem();
goShortDialogueItem10.Name = "GoShortDialogueItem10";
goShortDialogueItem10.MillisecondDelay = 500;
OutputAction goShortItem10ToItem11 = new OutputAction();
goShortItem10ToItem11.OutputList.Add("At what level would you like to set your target profit?");
goShortItem10ToItem11.TargetDialogueItemName = "GoShortDialogueItem11";
goShortDialogueItem10.ActionList.Add(goShortItem10ToItem11);
goShortDialogue.ItemList.Add(goShortDialogueItem10);
//Item11 : where to set target answer
SLTPOrderItem goShortDialogueItem11 = new SLTPOrderItem(SLTPOrderItem.SET_TARGET_PROFIT, MarketOrderItem.DIRECTION_SHORT);
goShortDialogueItem11.Name = "GoShortDialogueItem11";
goShortDialogueItem11.MillisecondDelay = 500;
LimitExecutionAction goShortItem11ToItem12 = new LimitExecutionAction();
goShortItem11ToItem12.InputList.Add("success");
goShortItem11ToItem12.TargetDialogueItemName = "GoShortDialogueItem12";
goShortDialogueItem11.ActionList.Add(goShortItem11ToItem12);
ResponseAction goShortItem11ToItem10 = new ResponseAction();
goShortItem11ToItem10.InputList.Add("failure");
goShortItem11ToItem10.OutputList.Add("Your limit was on the wrong side of the market, try again");
goShortItem11ToItem10.TargetDialogueItemName = "GoShortDialogueItem10";
goShortDialogueItem11.ActionList.Add(goShortItem11ToItem10);
goShortDialogue.ItemList.Add(goShortDialogueItem11);
//Item12 : Everything done, return to main dialogue
InteractionItem goShortDialogueItem12 = new InteractionItem();
goShortDialogueItem12.Name = "GoShortDialogueItem12";
goShortDialogueItem12.MillisecondDelay = 1500;
OutputAction goShortItem12ToMainDialogue = new OutputAction();
goShortItem12ToMainDialogue.OutputList.Add("All is set, good luck and have a nice day!");
goShortItem12ToMainDialogue.TargetDialogueItemName = "MainDialogueItem1";
goShortItem12ToMainDialogue.BrainProcessToDeactivate = "GoShortDialogue";
goShortItem12ToMainDialogue.BrainProcessToActivate = "MainDialogue";
goShortDialogueItem12.ActionList.Add(goShortItem12ToMainDialogue);
goShortDialogue.ItemList.Add(goShortDialogueItem12);
/*
* goShort Dialogue Process end
*/
FinalizeSetup();
}
public OutputAction <TElement> FromObservable <TElement>(Func <IObservable <TElement> > workFactory, IObservable <bool> enabledIf = null)
{
return(OutputAction <TElement> .FromObservable(workFactory, schedulerProvider.MainScheduler, enabledIf));
}
private ActionsControllerPressManager AddOutputActionHandler(PressHandlerDelegate <DirectionActionChange> handler, OutputAction outputAction)
{
AddHandler(handler,
DirectionActionChangeComparator,
ActionsController.DirectionActionPressed[outputAction],
ActionsController.DirectionActionUnpressed[outputAction]);
return(this);
}
public ChristmasAgent()
{
Name = "ChristmasAgent";
DialogueProcess openingDialogue = new DialogueProcess();
openingDialogue.Name = "openingDialogue";
openingDialogue.ActiveOnStartup = true;
openingDialogue.SetOwnerAgent(this);
BrainProcessList.Add(openingDialogue);
InteractionItem openingItem = new InteractionItem();
//openingItem.MillisecondDelay = 5000; // TODO: Just delays windows opening
openingDialogue.ItemList.Add(openingItem);
openingItem.Name = "openingItem";
OutputAction initialGreetingAction = new OutputAction();
openingItem.ActionList.Add(initialGreetingAction);
initialGreetingAction.OutputList.Add("Hello");
initialGreetingAction.OutputList.Add("Hi");
initialGreetingAction.OutputList.Add("Hey");
InteractionItem howWasChristmasItem = new InteractionItem(); //Doesn't work with dialogueitem?
openingDialogue.ItemList.Add(howWasChristmasItem);
howWasChristmasItem.Name = "howWasChristmasItem";
initialGreetingAction.TargetDialogueItemName = howWasChristmasItem.Name;
ResponseAction howWasChristmasAction = new ResponseAction();
howWasChristmasAction.InputList.Add("Hello");
howWasChristmasAction.InputList.Add("Hi");
howWasChristmasAction.InputList.Add("Hey");
howWasChristmasAction.OutputList.Add("How was christmas?");
howWasChristmasAction.OutputList.Add("How was your christmas?");
//howWasChristmasAction.OutputList.Add("bla");
howWasChristmasItem.ActionList.Add(howWasChristmasAction);
DialogueProcess christmasDialogue = new DialogueProcess();
christmasDialogue.Name = "christmasDialogue";
christmasDialogue.ActiveOnStartup = false;
christmasDialogue.SetOwnerAgent(this);
BrainProcessList.Add(christmasDialogue);
howWasChristmasAction.BrainProcessToActivate = christmasDialogue.Name;
InteractionItem christmasInquiryStartItem = new InteractionItem();
christmasInquiryStartItem.Name = "christmasInquiryStartItem";
christmasDialogue.ItemList.Add(christmasInquiryStartItem);
christmasDialogue.ProcessActivatedOnFailure = openingDialogue.Name;
ResponseAction ra_good = new ResponseAction();
christmasInquiryStartItem.ActionList.Add(ra_good);
ra_good.BrainProcessToDeactivate = christmasDialogue.Name;
ra_good.InputList.Add("Good");
ra_good.InputList.Add("Alright");
ra_good.InputList.Add("Great");
ra_good.OutputList.Add("I'm very happy to hear that!");
ra_good.OutputList.Add("Good for you!");
ra_good.OutputList.Add("Lovely!");
// ================================================================
//Good christmas inquiry
// ================================================================
DialogueProcess goodChristmasDialogue = new DialogueProcess();
goodChristmasDialogue.Name = "goodChristmasDialogue";
goodChristmasDialogue.ActiveOnStartup = false;
goodChristmasDialogue.SetOwnerAgent(this);
BrainProcessList.Add(goodChristmasDialogue);
ra_good.BrainProcessToActivate = goodChristmasDialogue.Name;
InteractionItem goodChristmasItem = new InteractionItem();
goodChristmasItem.Name = "goodChristmasItem";
ra_good.TargetDialogueItemName = goodChristmasItem.Name;
goodChristmasItem.MillisecondDelay = 500;
OutputAction anythingElse = new OutputAction();
anythingElse.OutputList.Add("Did you want to talk about anything else?");
anythingElse.OutputList.Add("Anything else on your mind?");
//anythingElse.BrainProcessToDeactivate = christmasDialogue.Name;
goodChristmasItem.ActionList.Add(anythingElse);
goodChristmasDialogue.ItemList.Add(goodChristmasItem);
InteractionItem goodChristmasResponseItem = new InteractionItem();
goodChristmasResponseItem.Name = "goodChristmasResponseItem";
//goodChristmasDialogue.ItemList.Add(goodChristmasResponseItem);
anythingElse.TargetDialogueItemName = goodChristmasResponseItem.Name;
ResponseAction nothingElse = new ResponseAction();
nothingElse.InputList.Add("No");
nothingElse.InputList.Add("That's not it");
nothingElse.InputList.Add("Nope");
nothingElse.OutputList.Add("Ok, see you later!");
nothingElse.OutputList.Add("Good.");
nothingElse.OutputList.Add("Good bye!");
goodChristmasResponseItem.ActionList.Add(nothingElse);
ResponseAction somethingElse = new ResponseAction();
somethingElse.InputList.Add("Yes");
somethingElse.InputList.Add("Yeah");
somethingElse.InputList.Add("Aye");
somethingElse.OutputList.Add("*Crickets*");
somethingElse.OutputList.Add("Tell it to someone else.");
somethingElse.OutputList.Add("I don't want to hear it.");
goodChristmasResponseItem.ActionList.Add(somethingElse);
goodChristmasDialogue.ItemList.Add(goodChristmasResponseItem);
// ================================================================
// Branch end
// ================================================================
ResponseAction ra_bad = new ResponseAction();
christmasInquiryStartItem.ActionList.Add(ra_bad);
ra_bad.BrainProcessToDeactivate = openingDialogue.Name;
ra_bad.InputList.Add("Bad");
ra_bad.InputList.Add("Awful");
ra_bad.InputList.Add("Terrible");
Random random = new Random();
double r = random.NextDouble();
if (r < 0.25)
{
ra_bad.OutputList.Add("I'm sorry to hear that, next year will be better.");
ra_bad.OutputList.Add("Ooh a new UDP packet, gotta go!");
}
else
{
ra_bad.OutputList.Add("Were you unhappy with your presents?");
ra_bad.OutputList.Add("Were you disappointed with your presents?");
DialogueProcess presentsDialogue = new DialogueProcess();
presentsDialogue.Name = "presentsDialogue";
presentsDialogue.ActiveOnStartup = false;
BrainProcessList.Add(presentsDialogue); //MUST add to list, will show in memory regardless though
ra_bad.BrainProcessToActivate = presentsDialogue.Name;
InteractionItem presentsItem = new InteractionItem();
presentsDialogue.ItemList.Add(presentsItem);
ResponseAction ra_good_presents = new ResponseAction();
presentsItem.ActionList.Add(ra_good_presents);
//ra_good_presents.BrainProcessToDeactivate = helloDialogue.Name;
ra_good_presents.InputList.Add("No");
ra_good_presents.InputList.Add("That's not it");
ra_good_presents.InputList.Add("Nope");
ra_good_presents.OutputList.Add("Then I can't help you.");
ra_good_presents.OutputList.Add("In that case, I can't help you.");
//Branch end
ResponseAction ra_bad_presents = new ResponseAction();
presentsItem.ActionList.Add(ra_bad_presents);
//ra_bad_presents.BrainProcessToDeactivate = helloDialogue.Name;
ra_bad_presents.InputList.Add("Yes");
ra_bad_presents.InputList.Add("Yeah");
ra_bad_presents.InputList.Add("Aye");
ra_bad_presents.InputList.Add("Yes they were cheap");
ra_bad_presents.OutputList.Add("Shall I add your friends and family to your list of enemies?");
InteractionItem enemiesItem = new InteractionItem();
presentsDialogue.ItemList.Add(enemiesItem);
enemiesItem.Name = "enemiesItem";
ra_bad_presents.TargetDialogueItemName = enemiesItem.Name;
ResponseAction enemiesAction = new ResponseAction();
enemiesItem.ActionList.Add(enemiesAction);
enemiesAction.InputList.Add("Yes");
enemiesAction.InputList.Add("Yes, and their pets");
enemiesAction.OutputList.Add("They've been added to your list of mortal enemies.");
enemiesAction.OutputList.Add("Done. You're a terrible person.");
ResponseAction noEnemiesAction = new ResponseAction();
enemiesItem.ActionList.Add(noEnemiesAction);
noEnemiesAction.InputList.Add("No");
noEnemiesAction.InputList.Add("Don't do that");
noEnemiesAction.InputList.Add("Nope");
noEnemiesAction.OutputList.Add("I'm going to do it anyway. Good bye!");
noEnemiesAction.OutputList.Add("Maybe next year. See you then!");
/*
* MemoryAccessItem readEnemyItem = new MemoryAccessItem();
* readEnemyItem.Name = "mai";
* enemiesAction.TargetDialogueItemName = readEnemyItem.Name;
* ReadByTagAction rbta = new ReadByTagAction();
* readEnemyItem.ActionList.Add(rbta);
*
* MemoryItem mi = new MemoryItem();
* mi.Content = "Friends and family and their pets";
* mi.Tag = "MortalEnemies";
* WorkingMemory.InsertItem(mi);
* rbta.Tag = mi.Tag;
*/
}
}
/*
* Lightness
* Hue 0 1 2
* 0 / push pop
* 1 add sub mul
* 2 div mod not
* 3 greater pointer switch
* 4 dup roll in number
* 5 in char out number out char
*/
private void PerformInstruction(int fromColorIndex, int toColorIndex, int codelCount)
{
int hueDiff = HueDiff(fromColorIndex, toColorIndex);
int lightnessDiff = LightnessDiff(fromColorIndex, toColorIndex);
Debug.WriteLine($"PerformInstruction: From{ColorIndexToString(fromColorIndex)} to {ColorIndexToString(toColorIndex)} => Hue:{hueDiff} Lightness:{lightnessDiff}");
switch (hueDiff)
{
case 0: // NOP, Push, Pop
switch (lightnessDiff)
{
case 0: // NOP
Debug.WriteLine("Action: NOP");
break;
case 1: // Push
Debug.WriteLine($"Action: PUSH {codelCount}");
Stack.Push(codelCount);
break;
case 2: // Pop
if (Stack.Count == 0)
{
Debug.WriteLine("Action: POP failed: stack underflow");
}
else
{
Debug.WriteLine("Action: POP");
Stack.Pop(); // Pop and discard
}
break;
}
break;
case 1: // Add, Sub, Mul
switch (lightnessDiff)
{
case 0: // Add
// Pop 2 values, add them and push back result
PerformMathOperation('+');
break;
case 1: // Sub
// Pop 2 values, sub (top from second top) them and push back result
PerformMathOperation('-');
break;
case 2: // Mul
// Pop 2 values, multiply them and push back result
PerformMathOperation('*');
break;
}
break;
case 2: // Div, Mod, Not
switch (lightnessDiff)
{
case 0: // Div
// Pop 2 values, divide (second top by top) them and push back result
PerformMathOperation('/');
break;
case 1: // Mod
// Pop 2 values, mod (second top modulo top) them and push back result
PerformMathOperation('%');
break;
case 2: // Not
// Pop 1 value, not (0->1, 0 otherwise) it and push back result
if (Stack.Count == 0)
{
Debug.WriteLine("Action: NOT failed: stack underflow");
}
else
{
int operand = Stack.Pop();
int result = operand == 0
? 1
: 0;
Debug.WriteLine($"Action: NOT({operand})={result}");
Stack.Push(result);
}
break;
}
break;
case 3: // greater, pointer, switch
switch (lightnessDiff)
{
case 0: // Greater
// Pop 2 values, if second top > top push 1, push 0 otherwise
if (Stack.Count < 2)
{
Debug.WriteLine("Action: GREATER failed: stack underflow");
}
else
{
int operand2 = Stack.Pop();
int operand1 = Stack.Pop();
int result = operand1 > operand2
? 1
: 0;
Debug.WriteLine($"Action: GREATER({operand1},{operand2})={result}");
Stack.Push(result);
}
break;
case 1: // Pointer
// Pop 1 value, turn DP clockwise if positive, counterclockwise otherwise
if (Stack.Count == 0)
{
Debug.WriteLine("Action: POINTER failed: stack underflow");
}
else
{
int operand = Stack.Pop();
int absOperand = operand;
Func <PointerDirections, PointerDirections> func;
if (absOperand > 0)
{
func = TurnDirectionPointerClockwise;
}
else
{
absOperand = -absOperand;
func = TurnDirectionPointerCounterClockwise;
}
for (int i = 0; i < absOperand % 4; i++)
{
DirectionPointer = func(DirectionPointer);
}
Debug.WriteLine($"Action: POINTER({operand})={DirectionPointer}");
}
break;
case 2: // Switch
// Pop 1 value, toggle CC that many times
if (Stack.Count == 0)
{
Debug.WriteLine("Action: SWITCH failed: stack underflow");
}
else
{
int operand = Stack.Pop();
for (int i = 0; i < operand % 4; i++)
{
CodelChooser = ToggleCodelChooser(CodelChooser);
}
Debug.WriteLine($"Action: SWITCH({operand})={CodelChooser}");
}
break;
}
break;
case 4: // dup, roll, in number
switch (lightnessDiff)
{
case 0: // Duplicate
// Push a copy of top value
if (Stack.Count == 0)
{
Debug.WriteLine("Action: DUPLICATE failed: stack underflow");
}
else
{
int operand = Stack.Peek();
Stack.Push(operand);
Debug.WriteLine($"Action: DUPLICATE({operand})");
}
break;
case 1: // Roll
// Pop 2 values, roll remaining stack entries to a depth equals to the second top by a number of rolls equal to top (see http://www.dangermouse.net/esoteric/piet.html)
// roll of depth k: move top at position k in stack and move up every value above k'th position
if (Stack.Count < 2)
{
Debug.WriteLine("Action: ROLL failed: stack underflow");
}
else
{
int roll = Stack.Pop();
int depth = Stack.Pop();
if (depth < 0)
{
Debug.WriteLine($"Action: ROLL failed: negative depth {depth}");
}
else if (Stack.Count < depth)
{
Debug.WriteLine($"Action: ROLL failed: stack underflow {depth}");
}
else
{
Stack.Roll(roll, depth);
}
}
break;
case 2: // In number
// Read a number from stdin and push it
string inputAsString = InputFunc?.Invoke();
int inputNumber;
if (!int.TryParse(inputAsString, out inputNumber))
{
Debug.WriteLine($"Action: IN NUMBER failed: invalid input {inputAsString}");
}
else
{
Debug.WriteLine($"Action: IN NUMBER({inputNumber})");
Stack.Push(inputNumber);
}
break;
}
break;
case 5: // in char, out number, out char
switch (lightnessDiff)
{
case 0: // In char
// Read a char from stdin and push it
string inputAsString = InputFunc?.Invoke();
if (string.IsNullOrEmpty(inputAsString))
{
Debug.WriteLine("Action: IN CHAR failed: null or empty input");
}
else
{
int inputChar = inputAsString[0] % 255;
Debug.WriteLine($"Action: IN CHAR({inputChar})");
Stack.Push(inputChar);
}
break;
case 1: // Out number
// Pop 1 value, print it on stdout as number
if (Stack.Count == 0)
{
Debug.WriteLine("Action: OUT NUMBER failed: stack underflow");
}
else
{
int operand = Stack.Pop();
Debug.WriteLine($"Action: OUT NUMBER({operand})");
OutputAction?.Invoke(operand.ToString());
}
break;
case 2: // Out char
// Pop 1 value, print it on stdout as char
if (Stack.Count == 0)
{
Debug.WriteLine("Action: OUT CHAR failed: stack underflow");
}
else
{
int outputAsInt = Stack.Pop();
char operand = (char)(outputAsInt % 255);
Debug.WriteLine($"Action: OUT CHAR({operand})");
OutputAction?.Invoke(operand.ToString());
}
break;
}
break;
}
}
public PushBusActionOutputAction(OutputAction child = null)
: base(child)
{
}
public DiagnosticPipeline(
IHealthReporter healthReporter,
IReadOnlyCollection <IObservable <EventData> > inputs,
IReadOnlyCollection <IFilter> globalFilters,
IReadOnlyCollection <EventSink> sinks,
DiagnosticPipelineConfiguration pipelineConfiguration = null,
bool disposeDependencies = false)
{
Requires.NotNull(healthReporter, nameof(healthReporter));
Requires.NotNull(inputs, nameof(inputs));
Requires.Argument(inputs.Count > 0, nameof(inputs), "There must be at least one input");
Requires.NotNull(sinks, nameof(sinks));
Requires.Argument(sinks.Count > 0, nameof(sinks), "There must be at least one sink");
this.eventsInProgress = 0;
this.pipelineConfiguration = pipelineConfiguration ?? new DiagnosticPipelineConfiguration();
// An estimatie how many batches of events to allow inside the pipeline.
// We want to be able to process full buffer of events, but also have enough batches in play in case of high concurrency.
int MaxNumberOfBatchesInProgress = Math.Max(
5 * this.pipelineConfiguration.MaxConcurrency,
this.pipelineConfiguration.PipelineBufferSize / this.pipelineConfiguration.MaxEventBatchSize);
this.Inputs = inputs;
this.Sinks = sinks;
// Just play nice and make sure there is always something to enumerate on
this.GlobalFilters = globalFilters ?? new IFilter[0];
this.HealthReporter = healthReporter;
this.cancellationTokenSource = new CancellationTokenSource();
var propagateCompletion = new DataflowLinkOptions()
{
PropagateCompletion = true
};
this.pipelineLinkDisposables = new List <IDisposable>();
this.pipelineCompletionTasks = new List <Task>();
var inputBuffer = new BufferBlock <EventData>(
new DataflowBlockOptions()
{
BoundedCapacity = this.pipelineConfiguration.PipelineBufferSize,
CancellationToken = this.cancellationTokenSource.Token
});
this.pipelineHead = inputBuffer;
this.pipelineCompletionTasks.Add(inputBuffer.Completion);
var batcher = new BatchBlock <EventData>(
this.pipelineConfiguration.MaxEventBatchSize,
new GroupingDataflowBlockOptions()
{
BoundedCapacity = this.pipelineConfiguration.MaxEventBatchSize,
CancellationToken = this.cancellationTokenSource.Token
}
);
this.pipelineLinkDisposables.Add(inputBuffer.LinkTo(batcher, propagateCompletion));
this.pipelineCompletionTasks.Add(batcher.Completion);
this.pipelineLinkDisposables.Add(new Timer(
(unused) => batcher.TriggerBatch(),
state: null,
dueTime: TimeSpan.FromMilliseconds(this.pipelineConfiguration.MaxBatchDelayMsec),
period: TimeSpan.FromMilliseconds(this.pipelineConfiguration.MaxBatchDelayMsec)));
ISourceBlock <EventData[]> sinkSource;
FilterAction filterTransform;
if (this.GlobalFilters.Count > 0)
{
filterTransform = new FilterAction(
this.GlobalFilters,
this.cancellationTokenSource.Token,
MaxNumberOfBatchesInProgress,
this.pipelineConfiguration.MaxConcurrency,
healthReporter,
this.OnEventsFilteredOut);
var globalFiltersBlock = filterTransform.GetFilterBlock();
this.pipelineLinkDisposables.Add(batcher.LinkTo(globalFiltersBlock, propagateCompletion));
this.pipelineCompletionTasks.Add(globalFiltersBlock.Completion);
sinkSource = globalFiltersBlock;
}
else
{
sinkSource = batcher;
}
if (sinks.Count > 1)
{
// After broadcasting we will effectively have (sinks.Count - 1) * batch.Length more events in the pipeline,
// because the broadcaster is cloning the events for the sake of each sink (filters-output combination).
var eventCounter = new TransformBlock <EventData[], EventData[]>(
(batch) => { Interlocked.Add(ref this.eventsInProgress, (sinks.Count - 1) * batch.Length); return(batch); },
new ExecutionDataflowBlockOptions()
{
BoundedCapacity = MaxNumberOfBatchesInProgress,
CancellationToken = this.cancellationTokenSource.Token
});
this.pipelineLinkDisposables.Add(sinkSource.LinkTo(eventCounter, propagateCompletion));
this.pipelineCompletionTasks.Add(eventCounter.Completion);
var broadcaster = new BroadcastBlock <EventData[]>(
(events) => events?.Select((e) => e.DeepClone()).ToArray(),
new DataflowBlockOptions()
{
BoundedCapacity = MaxNumberOfBatchesInProgress,
CancellationToken = this.cancellationTokenSource.Token
});
this.pipelineLinkDisposables.Add(eventCounter.LinkTo(broadcaster, propagateCompletion));
this.pipelineCompletionTasks.Add(broadcaster.Completion);
sinkSource = broadcaster;
}
foreach (var sink in sinks)
{
ISourceBlock <EventData[]> outputSource = sinkSource;
if (sink.Filters != null && sink.Filters.Count > 0)
{
filterTransform = new FilterAction(
sink.Filters,
this.cancellationTokenSource.Token,
MaxNumberOfBatchesInProgress,
this.pipelineConfiguration.MaxConcurrency,
healthReporter,
this.OnEventsFilteredOut);
var filterBlock = filterTransform.GetFilterBlock();
this.pipelineLinkDisposables.Add(sinkSource.LinkTo(filterBlock, propagateCompletion));
this.pipelineCompletionTasks.Add(filterBlock.Completion);
outputSource = filterBlock;
}
OutputAction outputAction = new OutputAction(
sink.Output,
this.cancellationTokenSource.Token,
MaxNumberOfBatchesInProgress,
this.pipelineConfiguration.MaxConcurrency,
healthReporter,
(eventsSentCount) => Interlocked.Add(ref this.eventsInProgress, -eventsSentCount));
var outputBlock = outputAction.GetOutputBlock();
this.pipelineLinkDisposables.Add(outputSource.LinkTo(outputBlock, propagateCompletion));
this.pipelineCompletionTasks.Add(outputBlock.Completion);
}
IObserver <EventData> inputBufferObserver = new TargetBlockObserver <EventData>(
inputBuffer,
this.HealthReporter,
() => Interlocked.Increment(ref this.eventsInProgress));
this.inputSubscriptions = new List <IDisposable>(inputs.Count);
foreach (var input in inputs)
{
this.inputSubscriptions.Add(input.Subscribe(inputBufferObserver));
}
this.disposed = false;
this.disposeDependencies = disposeDependencies;
}
