/// <summary>
/// Adds a new <see cref="MessageItem"/> for the specified <see cref="MessageItem.Property"/>, <see cref="MessageType"/>, text format and additional values included in the text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem Add(string property, MessageType type, LText format, params object?[] values)
{
MessageItem item = MessageItem.CreateMessage(property, type, format, values);
this.Add(item);
return(item);
}
/// <summary>
/// Adds a new <see cref="MessageItem"/> for a specified <see cref="MessageType"/>, text format and additional values included in the text.
/// </summary>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem Add(MessageType type, LText format, params object[] values)
{
MessageItem item = MessageItem.CreateMessage(type, format, values);
this.Add(item);
return(item);
}
/// <summary>
/// Adds a new <see cref="MessageItem"/> for a specified <see cref="MessageType"/> and text.
/// </summary>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem Add(MessageType type, LText text)
{
MessageItem item = MessageItem.CreateMessage(type, text);
this.Add(item);
return(item);
}
/// <summary>
/// Adds a new <see cref="MessageItem"/> for the specified <see cref="MessageItem.Property"/>, <see cref="MessageType"/> and text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem Add(string property, MessageType type, LText text)
{
MessageItem item = MessageItem.CreateMessage(property, type, text);
this.Add(item);
return(item);
}
/// <summary>
/// Creates a new <see cref="MessageItem"/> with a specified <see cref="MessageType"/> and text.
/// </summary>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public static MessageItem CreateMessage(MessageType type, LText text)
{
return(new MessageItem
{
Type = type,
Text = text
});
}
/// <summary>
/// Creates a new <see cref="MessageItem"/> with a specified <see cref="MessageType"/>, text format and and additional values included in the text.
/// </summary>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public static MessageItem CreateMessage(MessageType type, LText format, params object[] values)
{
return(new MessageItem
{
Type = type,
Text = string.Format(format, values)
});
}
public void DisplayResponses(LText text)
{
LText[] responses = currentConversation.GetResponses(text);
if (responses != null)
{
responder.SetResponses(responses);
}
}
/// <summary>
/// Creates a new <see cref="MessageItem"/> with a specified <see cref="MessageType"/>, text format and and additional values included in the text.
/// </summary>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public static MessageItem CreateMessage(MessageType type, LText format, params object[] values)
{
return(new MessageItem
{
Type = type,
Text = string.Format(System.Globalization.CultureInfo.CurrentCulture, format, values)
});
}
public void AddNew()
{
var list = new List <LText>(texts);
var item = new LText();
item.key = list.Count.ToString("D3");
list.Add(item);
texts = list.ToArray();
}
/// <summary>
/// Creates a new <see cref="MessageType.Error"/> <see cref="MessageItem"/> with the specified <see cref="Property"/> and text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public static MessageItem CreateErrorMessage(string property, LText text)
{
return(new MessageItem
{
Property = property,
Type = MessageType.Error,
Text = text
});
}
/// <summary>
/// Creates a new <see cref="MessageItem"/> with the specified <see cref="Property"/>, <see cref="MessageType"/> and text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="type">The <see cref="MessageType"/>.</param>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public static MessageItem CreateMessage(string property, MessageType type, LText text)
{
return(new MessageItem
{
Property = property,
Type = type,
Text = text
});
}
/// <summary>
/// Creates a new <see cref="MessageType.Error"/> <see cref="MessageItem"/> with the specified <see cref="Property"/>, text format and additional values included in the text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public static MessageItem CreateErrorMessage(string property, LText format, params object[] values)
{
return(new MessageItem
{
Property = property,
Type = MessageType.Error,
Text = string.Format(System.Globalization.CultureInfo.CurrentCulture, format, values)
});
}
/// <summary>
/// Creates a new <see cref="MessageType.Error"/> <see cref="MessageItem"/> with the specified <see cref="Property"/>, text format and additional values included in the text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public static MessageItem CreateErrorMessage(string property, LText format, params object[] values)
{
return(new MessageItem
{
Property = property,
Type = MessageType.Error,
Text = string.Format(format, values)
});
}
/// <summary>
/// Initializes a new instance of the <see cref="CompareValueRule{TEntity, TProperty}"/> class specifying the compare to property.
/// </summary>
/// <param name="compareOperator">The <see cref="CompareOperator"/>.</param>
/// <param name="compareToPropertyExpression">The <see cref="Expression"/> to reference the compare to entity property.</param>
/// <param name="compareToText">The compare to text <see cref="LText"/> to be passed for the error message (default is to derive the text from the property itself).</param>
public ComparePropertyRule(CompareOperator compareOperator, Expression <Func <TEntity, TCompareProperty> > compareToPropertyExpression, LText compareToText = null) : base(compareOperator)
{
if (compareToPropertyExpression == null)
{
throw new ArgumentNullException("compareToPropertyExpression");
}
_compareTo = PropertyExpression <TEntity, TCompareProperty> .Create(compareToPropertyExpression, true);
_compareToText = compareToText;
}
/// <summary>
/// Specifies that the collection is to be checked for duplicates using the specified item property.
/// </summary>
/// <typeparam name="TItemProperty">The item property <see cref="Type"/>.</typeparam>
/// <param name="propertyExpression">The <see cref="Expression"/> to reference the item property that is being duplicate checked.</param>
/// <param name="duplicateText">The duplicate text <see cref="LText"/> to be passed for the error message (default is to derive the text from the property itself where possible).</param>
/// <returns>The <see cref="CollectionRuleItem{TItemEntity}"/> instance to support chaining/fluent.</returns>
public CollectionRuleItem <TItemEntity> DuplicateCheck <TItemProperty>(Expression <Func <TItemEntity, TItemProperty> > propertyExpression, LText duplicateText = null)
{
if (_duplicateCheck)
{
throw new InvalidOperationException("A DuplicateCheck or UniqueKeyDuplicateCheck can only be specified once.");
}
_propertyExpression = PropertyExpression.Create(Check.NotNull(propertyExpression, nameof(propertyExpression)), true);
_duplicateText = duplicateText ?? _propertyExpression.Text;
_duplicateCheck = true;
return(this);
}
/// <summary>
/// Runs the <paramref name="func"/> checking against the expected outcomes.
/// </summary>
/// <param name="func">The function to execute.</param>
/// <returns>The resulting <see cref="IValidationContextBase"/> where applicable; otherwise, <c>null</c>.</returns>
public IValidationContextBase?Run(Func <IValidationContextBase> func)
{
PrepareExecutionContext(_username, _args);
ExecutionContext.Current.OperationType = _operationType;
if (IsExpectingError && !_expectedErrorType.HasValue)
{
_expectedErrorType = ErrorType.ValidationError;
}
try
{
var vc = Check.NotNull(func, nameof(func))();
if (vc == null)
{
Assert.Fail("The validation function returned a null IValidationContext result.");
}
if (vc !.HasErrors)
{
LogStatus(ErrorType.ValidationError, new LText("Beef.ValidationException"), vc.Messages);
}
else
{
LogStatus(null, null, null);
}
if (_expectedErrorType.HasValue)
{
if (!vc !.HasErrors && _expectedErrorType != ErrorType.ValidationError)
{
Assert.Fail($"Expected ErrorType was '{_expectedErrorType}'; actual was '{ErrorType.ValidationError}'.");
}
if (_expectedErrorMessage != null)
{
var message = new LText("Beef.ValidationException");
if (_expectedErrorMessage != message)
{
Assert.Fail($"Expected ErrorMessage was '{_expectedErrorMessage}'; actual was '{message}'.");
}
}
}
if (_expectedMessages != null)
{
ExpectValidationException.CompareExpectedVsActual(_expectedMessages, vc !.Messages);
}
return(vc);
}
public void SendText(LText text)
{
AddText(text);
HideResponsePanel();
LText response = currentConversation.ChooseResponse(mostRecentMessage);
if (response != null)
{
StartCoroutine(NPCRespondDelayed(currentContact.conversation, response));
}
else
{
currentContact.conversation.MarkAsComplete();
}
currentContact.Refresh();
}
IEnumerator NPCRespondDelayed(LConversation conversation, LText response)
{
yield return(new WaitForSeconds(NPCResponseDelay));
EventController.Event(LEvent.Message);
if (isContactsOpen)
{
conversation.AddMessage(response);
}
else
{
AddText(response);
DisplayResponses(mostRecentMessage);
}
// Refreshes the display for the current contact:
currentContact.Refresh();
data.Save();
}
/// <summary>
/// Specifies that the collection is to be checked for duplicates using the item's <see cref="IUniqueKey"/> value.
/// </summary>
/// <param name="duplicateText">The duplicate text <see cref="LText"/> to be passed for the error message (default is to derive the text from the property itself where possible).</param>
/// <returns>The <see cref="CollectionRuleItem{TItemEntity}"/> instance to support chaining/fluent.</returns>
public CollectionRuleItem <TItemEntity> UniqueKeyDuplicateCheck(LText duplicateText = null)
{
if (_duplicateCheck)
{
throw new InvalidOperationException("A DuplicateCheck or UniqueKeyDuplicateCheck can only be specified once.");
}
if (ItemType.GetInterface(typeof(IUniqueKey).Name) == null)
{
throw new InvalidOperationException("A CollectionRuleItem ItemType '{_itemType.Name}' must implement 'IUniqueKey' to support UniqueKeyDuplicateCheck.");
}
IUniqueKey uk;
try
{
uk = (IUniqueKey)Activator.CreateInstance(ItemType);
}
catch (Exception ex)
{
throw new InvalidOperationException($"A CollectionRuleItem ItemType '{ItemType.Name}' could not be constructed as an IUniqueKey to infer UniqueKeyProperties: {ex.Message}");
}
if (!uk.HasUniqueKey || uk.UniqueKeyProperties == null || uk.UniqueKeyProperties.Length == 0)
{
throw new InvalidOperationException("A CollectionRule TProperty ItemType '{_itemType.Name}' must define the 'IUniqueKey.UniqueKeyProperties' to support CheckForDuplicates.");
}
_duplicateText = duplicateText;
if (_duplicateText == null && uk.UniqueKeyProperties.Length == 1)
{
_duplicateText = new EntityReflectorArgs().GetReflector(ItemType).GetProperty(uk.UniqueKeyProperties[0]).PropertyExpression.Text;
}
if (_duplicateText == null)
{
_duplicateText = "Unique Key";
}
_duplicateCheck = true;
return(this);
}
// Adds a visual text to the screen using an LText as the data source
public LTextBehaviour AddText(LText text, bool newText = true)
{
checkTextScrollView();
GameObject prefab = text.FromPlayer ? playerTextPrefab : npcTextPrefab;
GameObject textObject = Instantiate(prefab, messageParent) as GameObject;
Transform textTransform = textObject.transform;
textTransform.localScale = Vector3.one;
LTextBehaviour textBehaviour = textObject.GetComponent <LTextBehaviour>();
textBehaviour.SetText(text.Body);
textBehaviour.SetImage(currentContact.ContactSprite);
visualTexts.Add(textBehaviour);
mostRecentMessage = text;
theMessage = textObject;
if (newText)
{
currentContact.AddMessage(text);
}
scrollPosition.addText(theMessage);
return(textBehaviour);
}
public ConstValue(Type type)
{
if (type == typeof(string))
{
Type = new SType(typeof(LText));
Value = new LText(true, "");
return;
}
Type = new SType(type);
if (type.IsValueType)
{
Value = Activator.CreateInstance(type);
}
else
{
_value = null;
_valueString = "null";
_unityObject = null;
}
}
public ConstValue(string constValue, Type type)
{
if (type == typeof(string))
{
Type = new SType(typeof(LText));
Value = new LText(true, constValue);
return;
}
Type = new SType(type);
if (type == typeof(string))
{
constValue = JsonConvert.SerializeObject(new LText(false, constValue));
}
if (type == typeof(Boolean))
{
constValue = JsonConvert.SerializeObject(Boolean.Parse(constValue));
}
_valueString = constValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueValidator{T}"/> class.
/// </summary>
/// <param name="value">The value to validate.</param>
/// <param name="name">The value name (defaults to <see cref="ValueNameDefault"/>).</param>
/// <param name="text">The friendly text name used in validation messages (defaults to <paramref name="name"/> as sentence case where not specified).</param>
public ValueValidator(T value, string name = null, LText text = null)
{
ValidationValue = new ValidationValue <T>(null, value);
Name = string.IsNullOrEmpty(name) ? ValueNameDefault : name;
Text = text ?? Beef.CodeGen.CodeGenerator.ToSentenceCase(Name);
}
/// <summary>
/// Validates the value.
/// </summary>
/// <param name="value">The value to validate.</param>
/// <param name="name">The value name (defaults to <see cref="ValueValidator{T}.ValueNameDefault"/>).</param>
/// <param name="text">The friendly text name used in validation messages (defaults to <paramref name="name"/> as sentence case where not specified).</param>
/// <param name="throwOnError">Indicates to throw a <see cref="ValidationException"/> where an error was found.</param>
/// <returns>A <see cref="ValueValidatorResult{TEntity, TProperty}"/>.</returns>
public ValueValidatorResult <ValidationValue <T>, T> Validate(T value, string name = null, LText text = null, bool throwOnError = false)
{
var vv = new ValidationValue <T>(null, value);
var ctx = new PropertyContext <ValidationValue <T>, T>(new ValidationContext <ValidationValue <T> >(vv,
new ValidationArgs()), value, name ?? ValueValidator <T> .ValueNameDefault, null, text);
Invoke(ctx);
var res = new ValueValidatorResult <ValidationValue <T>, T>(ctx);
if (throwOnError)
{
res.ThrowOnError();
}
return(res);
}
/// <summary>
/// Adds a new <see cref="MessageType.Error"/> <see cref="MessageItem"/> for the specified <see cref="MessageItem.Property"/> and text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem AddError(string property, LText text)
{
return(Add(property, MessageType.Error, text));
}
/// <summary>
/// Adds a new <see cref="MessageType.Error"/> <see cref="MessageItem"/> for a specified text format and additional values included in the text.
/// </summary>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem AddError(LText format, params object[] values)
{
return(Add(MessageType.Error, format, values));
}
/// <summary>
/// Adds a new <see cref="MessageType.Error"/> <see cref="MessageItem"/> for a specified text.
/// </summary>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem AddError(LText text)
{
return(Add(MessageType.Error, text));
}
/// <summary>
/// Adds a new <see cref="MessageType.Info"/> <see cref="MessageItem"/> for a specified text format and additional values included in the text.
/// </summary>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem AddInfo(LText format, params object[] values)
{
return(Add(MessageType.Info, format, values));
}
/// <summary>
/// Adds a new <see cref="MessageType.Info"/> <see cref="MessageItem"/> for the specified <see cref="MessageItem.Property"/> and text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="text">The message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem AddInfo(string property, LText text)
{
return(Add(property, MessageType.Info, text));
}
/// <summary>
/// Adds a new <see cref="MessageType.Info"/> <see cref="MessageItem"/> for the specified <see cref="MessageItem.Property"/>, text format and and additional values included in the text.
/// </summary>
/// <param name="property">The property name.</param>
/// <param name="format">The composite format string.</param>
/// <param name="values">The values that form part of the message text.</param>
/// <returns>A <see cref="MessageItem"/>.</returns>
public MessageItem AddInfo(string property, LText format, params object[] values)
{
return(Add(property, MessageType.Info, format, values));
}
