public static ConditionEvent Start(ConditionalDelegate pTriggerCondition, Action pDoSomething)
{
return(mMediator.WaitForCondition(new ConditionEvent()
{
onTrigger = pDoSomething, triggerCondition = pTriggerCondition
}));
}
public void Set(ConditionEvent other)
{
id = other.id;
triggerCondition = other.triggerCondition;
onTrigger = other.onTrigger;
onUpdate = other.onUpdate;
}
private static IForm <PizzaOrder> BuildForm()
{
var builder = new FormBuilder <PizzaOrder>();
ConditionalDelegate <PizzaOrder> isBYO = (pizza) => pizza.Kind == PizzaOptions.BYOPizza;
ConditionalDelegate <PizzaOrder> isSignature = (pizza) => pizza.Kind == PizzaOptions.SignaturePizza;
ConditionalDelegate <PizzaOrder> isGourmet = (pizza) => pizza.Kind == PizzaOptions.GourmetDelitePizza;
ConditionalDelegate <PizzaOrder> isStuffed = (pizza) => pizza.Kind == PizzaOptions.StuffedPizza;
return(builder
// .Field(nameof(PizzaOrder.Choice))
.Field(nameof(PizzaOrder.Size))
.Field(nameof(PizzaOrder.Kind))
.Field("BYO.Crust", isBYO)
.Field("BYO.Sauce", isBYO)
.Field("BYO.Toppings", isBYO)
.Field(nameof(PizzaOrder.GourmetDelite), isGourmet)
.Field(nameof(PizzaOrder.Signature), isSignature)
.Field(nameof(PizzaOrder.Stuffed), isStuffed)
.AddRemainingFields()
.Confirm("Would you like a {Size}, {BYO.Crust} crust, {BYO.Sauce}, {BYO.Toppings} pizza?", isBYO)
.Confirm("Would you like a {Size}, {&Signature} {Signature} pizza?", isSignature, dependencies: new string[] { "Size", "Kind", "Signature" })
.Confirm("Would you like a {Size}, {&GourmetDelite} {GourmetDelite} pizza?", isGourmet)
.Confirm("Would you like a {Size}, {&Stuffed} {Stuffed} pizza?", isStuffed)
.Build()
);
}
private static IEnumerator <float> IEUpdate(Action pFirstUpdate, ConditionalDelegate pBreakCondition, Action pOnBreak, Action pLateUpdate, float pTime = 0)
{
while (true)
{
if (pBreakCondition())
{
if (pOnBreak != null)
{
pOnBreak();
}
break;
}
if (pFirstUpdate != null)
{
pFirstUpdate();
}
if (pTime > 0)
{
yield return(Timing.WaitForSeconds(pTime));
}
else
{
yield return(Timing.WaitForOneFrame);
}
if (pLateUpdate != null)
{
pLateUpdate();
}
}
}
public IFormBuilder <T> Confirm(string prompt, ConditionalDelegate <T> condition = null, IEnumerable <string> dependencies = null)
{
IFormBuilder <T> builder = this;
return(builder.Confirm(new PromptAttribute(prompt)
{
ChoiceFormat = "{1}", AllowDefault = BoolDefault.False
}, condition, dependencies));
}
public IFormBuilder <T> Field(string name, ConditionalDelegate <T> condition = null, ValidateDelegate <T> validate = null)
{
var field = (condition == null ? new FieldReflector <T>(name) : new Conditional <T>(name, condition));
if (validate != null)
{
field.SetValidation(validate);
}
return(AddField(field));
}
/// <summary>
/// Construct a confirmation.
/// </summary>
/// <param name="prompt">Confirmation prompt expressed using \ref patterns.</param>
/// <param name="condition">Delegate for whether confirmation applies.</param>
/// <param name="dependencies">Fields that must have values before confirmation can run.</param>
public Confirmation(PromptAttribute prompt, ConditionalDelegate <T> condition, IEnumerable <string> dependencies)
: base(Guid.NewGuid().ToString(), FieldRole.Confirm)
{
SetPrompt(prompt);
_condition = condition;
_dependencies = dependencies.ToArray();
var noStep = (dependencies.Count() > 0 ? new NextStep(dependencies) : new NextStep());
_next = (value, state) => value ? new NextStep() : noStep;
}
public void Set(CountdownEvent other)
{
id = other.id;
doSomething = other.doSomething;
breakCondition = other.breakCondition;
waitTime = other.waitTime;
unscaledTime = other.unscaledTime;
mElapsed = other.mElapsed;
mElapsedOffset = other.mElapsedOffset;
}
internal void SetPredicate(StateAction <TState> action, ConditionalDelegate predicate, string predicateDebuggerDisplay)
{
var foundAction = _Tokens.Values.SelectMany(cond => cond).FirstOrDefault(listAction => listAction.Action == action);
if (foundAction == default)
{
throw new NotImplementedException();
}
foundAction.Predicate = predicate;
foundAction.PredicateDebuggerDisplay = predicateDebuggerDisplay;
}
/// <summary>
/// Like an action node... but the function can return true/false and is mapped to success/failure.
/// </summary>
public BehaviourTreeBuilder Condition(string name, ConditionalDelegate fn)
{
if (parentNodeStack.Count <= 0)
{
throw new ApplicationException("Can't create an unnested ActionNode, it must be a leaf node.");
}
var conditionalNode = new Conditional(fn);
parentNodeStack.Peek().AddChild(conditionalNode);
return(this);
}
private static IEnumerator <float> IEWaitUntil(Action pAction, ConditionalDelegate pBreakCondition)
{
while (true)
{
if (pBreakCondition())
{
break;
}
yield return(Timing.WaitForOneFrame);
}
pAction();
}
static void Sort(int[] array, ConditionalDelegate condition)
{
int temp;
for (int i = 0; i < array.Length; i++)
{
for (int j = 0; j < array.Length; j++)
{
if (condition(array[i], array[j]))
{
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
public IFormBuilder <T> Confirm(PromptAttribute prompt, ConditionalDelegate <T> condition = null, IEnumerable <string> dependencies = null)
{
if (condition == null)
{
condition = state => true;
}
if (dependencies == null)
{
// Default next steps go from previous field ignoring confirmations back to next confirmation
// Last field before confirmation
var end = _form._steps.Count();
while (end > 0)
{
if (_form._steps[end - 1].Type == StepType.Field)
{
break;
}
--end;
}
var start = end;
while (start > 0)
{
if (_form._steps[start - 1].Type == StepType.Confirm)
{
break;
}
--start;
}
var fields = new List <string>();
for (var i = start; i < end; ++i)
{
if (_form._steps[i].Type == StepType.Field)
{
fields.Add(_form._steps[i].Name);
}
}
dependencies = fields;
}
var confirmation = new Confirmation <T>(prompt, condition, dependencies);
confirmation.Form = _form;
_form._fields.Add(confirmation);
_form._steps.Add(new ConfirmStep <T>(confirmation));
return(this);
}
//===
public static CoroutineHandle Update(Action pFirstUpdate, ConditionalDelegate pBreakCondition, Action pOnBreak, Action pLateUpdate, float pTime = 0)
{
return(Timing.RunCoroutine(IEUpdate(pFirstUpdate, pBreakCondition, pOnBreak, pLateUpdate, pTime)));
}
//===
public static CoroutineHandle WaitUntil(Action pAction, ConditionalDelegate pBreakCondition)
{
return(Timing.RunCoroutine(IEWaitUntil(pAction, pBreakCondition)));
}
public Conditional(ConditionalDelegate testCondition)
{ // Constructor to set up the test for the condition
_testCondition = testCondition;
} // Conditional
/// <summary>
/// Returns a return code equivalent to the test
/// -Returns Success if true
/// -Returns Failure if false
/// </summary>
/// <param name="test">the value to be tested</param>
public Conditional(ConditionalDelegate test)
{
_Bool = test;
}
private static IForm <PizzaOrder> BuildForm(bool noNumbers, bool ignoreAnnotations = false)
{
var form = new FormBuilder <PizzaOrder>(ignoreAnnotations);
ConditionalDelegate <PizzaOrder> isBYO = (pizza) => pizza.Kind == PizzaOptions.BYOPizza;
ConditionalDelegate <PizzaOrder> isSignature = (pizza) => pizza.Kind == PizzaOptions.SignaturePizza;
ConditionalDelegate <PizzaOrder> isGourmet = (pizza) => pizza.Kind == PizzaOptions.GourmetDelitePizza;
ConditionalDelegate <PizzaOrder> isStuffed = (pizza) => pizza.Kind == PizzaOptions.StuffedPizza;
// form.Configuration().DefaultPrompt.Feedback = FeedbackOptions.Always;
if (noNumbers)
{
form.Configuration.DefaultPrompt.ChoiceFormat = "{1}";
}
else
{
form.Configuration.DefaultPrompt.ChoiceFormat = "{0}. {1}";
}
return(form
.Message("Welcome to the pizza bot!!!")
.Message("Lets make pizza!!!")
.Field(nameof(PizzaOrder.NumberOfPizzas))
.Field(nameof(PizzaOrder.Size))
.Field(nameof(PizzaOrder.Kind))
.Field("Size")
.Field("BYO.HalfAndHalf", isBYO)
.Field("BYO.Crust", isBYO)
.Field("BYO.Sauce", isBYO)
.Field("BYO.Toppings", isBYO)
.Field("BYO.HalfToppings", (pizza) => isBYO(pizza) && pizza.BYO != null && pizza.BYO.HalfAndHalf)
.Message("Almost there!!! {*filled}", isBYO)
.Field(nameof(PizzaOrder.GourmetDelite), isGourmet)
.Field(nameof(PizzaOrder.Signature), isSignature)
.Field(nameof(PizzaOrder.Stuffed), isStuffed)
.Message("What we have is a {?{Signature} signature pizza} {?{GourmetDelite} gourmet pizza} {?{Stuffed} {&Stuffed}} {?{?{BYO.Crust} {&BYO.Crust}} {?{BYO.Sauce} {&BYO.Sauce}} {?{BYO.Toppings}}} pizza")
.Field("DeliveryAddress", validate:
async(state, value) =>
{
var result = new ValidateResult {
IsValid = true
};
var str = value as string;
if (str.Length == 0 || str[0] < '1' || str[0] > '9')
{
result.Feedback = "Address must start with number.";
result.IsValid = false;
}
else
{
result.Feedback = "Your address is fine.";
}
return result;
})
.AddRemainingFields()
.Message("Rating = {Rating:F1} and [{Rating:F2}]")
.Confirm("Would you like a {Size}, {[{BYO.Crust} {BYO.Sauce} {BYO.Toppings}]} pizza delivered to {DeliveryAddress}?", isBYO)
.Confirm("Would you like a {Size}, {&Signature} {Signature} pizza delivered to {DeliveryAddress}?", isSignature, dependencies: new string[] { "Size", "Kind", "Signature" })
.Confirm("Would you like a {Size}, {&GourmetDelite} {GourmetDelite} pizza delivered to {DeliveryAddress}?", isGourmet)
.Confirm("Would you like a {Size}, {&Stuffed} {Stuffed} pizza delivered to {DeliveryAddress}?", isStuffed)
.OnCompletionAsync(async(session, pizza) => Console.WriteLine("{0}", pizza))
.Build());
}
public MessageStep(PromptAttribute prompt, ConditionalDelegate <T> condition, IForm <T> form)
{
_name = "message" + form.Steps.Count.ToString();
_prompt = new Prompter <T>(prompt, form, null);
_condition = (condition == null ? (state) => true : condition);
}
/// <summary>
/// Returns a return code equivalent to the test
/// -Returns Success if true
/// -Returns Failure if false
/// </summary>
/// <param name="test">the value to be tested</param>
public Conditional(ConditionalDelegate test)
{
_Bool = test;
}
public IFormBuilder <T> Message(PromptAttribute prompt, ConditionalDelegate <T> condition = null)
{
_form._steps.Add(new MessageStep <T>(prompt, condition, _form));
return(this);
}
//METHODS
public BehaviorConditional(ConditionalDelegate condition)
{
Condition = condition;
}
public Conditional(string name, ConditionalDelegate <T> condition, bool ignoreAnnotations = false)
: base(name, ignoreAnnotations)
{
_condition = condition;
}
