487 lines
22 KiB
C#
487 lines
22 KiB
C#
|
#if USE_YARN2
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
|
||
|
|
|
||
|
|
namespace PixelCrushers.DialogueSystem.Yarn
|
||
|
|
{
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
// + Enum: BuiltInCommand
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
public enum BuiltInCommand : int
|
||
|
|
{
|
||
|
|
// Yarn built-in commands
|
||
|
|
Stop,
|
||
|
|
Wait,
|
||
|
|
|
||
|
|
// Dialogue System built-in commands
|
||
|
|
ClearAndAddStringFormatArg,
|
||
|
|
AddStringFormatArg,
|
||
|
|
StartConversation,
|
||
|
|
StopConversation,
|
||
|
|
PlaySequence,
|
||
|
|
|
||
|
|
// User defined command (or typo)
|
||
|
|
Unknown,
|
||
|
|
}
|
||
|
|
|
||
|
|
public static partial class BuiltInCommandExt
|
||
|
|
{
|
||
|
|
private static IReadOnlyDictionary<BuiltInCommand, string> _yarnNameMap = new Dictionary<BuiltInCommand, string>()
|
||
|
|
{
|
||
|
|
{ BuiltInCommand.Stop, "stop" },
|
||
|
|
{ BuiltInCommand.Wait, "wait" },
|
||
|
|
// { BuiltInCommand.PlaySequence, "seq" }, // This is actually a DS command, but we support it in Yarn scripts
|
||
|
|
};
|
||
|
|
|
||
|
|
private static IReadOnlyDictionary<BuiltInCommand, string> _luaNameMap = new Dictionary<BuiltInCommand, string>()
|
||
|
|
{
|
||
|
|
// Run sequence is defined in the Yarn commmands above, since we support it in all Yarn scripts
|
||
|
|
// It is still, however, considered a Dialogue System built-in command, not a Yarn one
|
||
|
|
{ BuiltInCommand.ClearAndAddStringFormatArg, "ds_clr_add_fmt_arg" },
|
||
|
|
{ BuiltInCommand.AddStringFormatArg, "ds_add_fmt_arg" },
|
||
|
|
{ BuiltInCommand.StopConversation, "ds_stp_cnv" },
|
||
|
|
};
|
||
|
|
|
||
|
|
private static HashSet<BuiltInCommand> _yarnCommands = new HashSet<BuiltInCommand>() { BuiltInCommand.Stop, BuiltInCommand.Wait };
|
||
|
|
private static HashSet<BuiltInCommand> _dsCommands = new HashSet<BuiltInCommand>() { BuiltInCommand.PlaySequence };
|
||
|
|
|
||
|
|
public static bool IsStop(this BuiltInCommand entry) => entry == BuiltInCommand.Stop;
|
||
|
|
public static bool IsWait(this BuiltInCommand entry) => entry == BuiltInCommand.Wait;
|
||
|
|
public static bool IsClearAndAddStringFormatArg(this BuiltInCommand entry) => entry == BuiltInCommand.ClearAndAddStringFormatArg;
|
||
|
|
public static bool IsAddStringFormatArg(this BuiltInCommand entry) => entry == BuiltInCommand.AddStringFormatArg;
|
||
|
|
// public static bool IsStartConversation(this BuiltInCommand entry) => entry == BuiltInCommand.StartConversation;
|
||
|
|
public static bool IsStopConversation(this BuiltInCommand entry) => entry == BuiltInCommand.StopConversation;
|
||
|
|
public static bool IsPlaySequence(this BuiltInCommand entry) => entry == BuiltInCommand.PlaySequence;
|
||
|
|
public static bool IsPlaySequence(string name) => name == "seq" || name == "sequence";
|
||
|
|
public static bool IsUnknown(this BuiltInCommand entry) => entry == BuiltInCommand.Unknown;
|
||
|
|
|
||
|
|
public static bool IsDialogueSystemCommand(this BuiltInCommand entry) => _dsCommands.Contains(entry);
|
||
|
|
public static bool IsYarnCommand(this BuiltInCommand entry) => _yarnCommands.Contains(entry);
|
||
|
|
|
||
|
|
public static string LuaName(this BuiltInCommand entry) => _luaNameMap[entry];
|
||
|
|
public static string YarnName(this BuiltInCommand entry) => entry.IsYarnCommand() ? _yarnNameMap[entry] : null;
|
||
|
|
|
||
|
|
static BuiltInCommandExt()
|
||
|
|
{
|
||
|
|
// Add all of Yarn's built-in commands to the Dialogue System's map of commands,
|
||
|
|
// and prepend 'ds_' to all of Yarn's command names to make their Lua complements.
|
||
|
|
var luaMap = (Dictionary<BuiltInCommand, string>)_luaNameMap;
|
||
|
|
foreach (var entry in _yarnNameMap) luaMap[entry.Key] = $"ds_{entry.Value}";
|
||
|
|
}
|
||
|
|
|
||
|
|
public static BuiltInCommand FromYarnSymbol(string symbol)
|
||
|
|
{
|
||
|
|
foreach (var entry in _yarnNameMap) if (entry.Value == symbol) return entry.Key;
|
||
|
|
return BuiltInCommand.Unknown;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
// + Enum: BuiltInFunction
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
public enum BuiltInFunction : int
|
||
|
|
{
|
||
|
|
Visited,
|
||
|
|
VisitedCount,
|
||
|
|
Random,
|
||
|
|
RandomRange,
|
||
|
|
Dice,
|
||
|
|
Round,
|
||
|
|
RoundPlaces,
|
||
|
|
Floor,
|
||
|
|
Ceil,
|
||
|
|
Inc,
|
||
|
|
Dec,
|
||
|
|
Decimal,
|
||
|
|
Int,
|
||
|
|
Unknown,
|
||
|
|
}
|
||
|
|
|
||
|
|
public static partial class BuiltInFunctionExt
|
||
|
|
{
|
||
|
|
private static IReadOnlyDictionary<BuiltInFunction, string> _yarnNameMap = new Dictionary<BuiltInFunction, string>()
|
||
|
|
{
|
||
|
|
{ BuiltInFunction.Visited, "visited" },
|
||
|
|
{ BuiltInFunction.VisitedCount, "visited_count" },
|
||
|
|
{ BuiltInFunction.Random, "random" },
|
||
|
|
{ BuiltInFunction.RandomRange, "random_range" },
|
||
|
|
{ BuiltInFunction.Dice, "dice" },
|
||
|
|
{ BuiltInFunction.Round, "round" },
|
||
|
|
{ BuiltInFunction.RoundPlaces, "round_places" },
|
||
|
|
{ BuiltInFunction.Floor, "floor" },
|
||
|
|
{ BuiltInFunction.Ceil, "ceil" },
|
||
|
|
{ BuiltInFunction.Inc, "inc" },
|
||
|
|
{ BuiltInFunction.Dec, "dec" },
|
||
|
|
{ BuiltInFunction.Decimal, "decimal" },
|
||
|
|
{ BuiltInFunction.Int, "int" },
|
||
|
|
};
|
||
|
|
|
||
|
|
private static IReadOnlyDictionary<BuiltInFunction, string> _luaNameMap = new Dictionary<BuiltInFunction, string>();
|
||
|
|
|
||
|
|
public static bool IsVisited(this BuiltInFunction entry) => entry == BuiltInFunction.Visited;
|
||
|
|
public static bool IsVisitedCount(this BuiltInFunction entry) => entry == BuiltInFunction.VisitedCount;
|
||
|
|
public static bool IsRandom(this BuiltInFunction entry) => entry == BuiltInFunction.Random;
|
||
|
|
public static bool IsRandomRange(this BuiltInFunction entry) => entry == BuiltInFunction.RandomRange;
|
||
|
|
public static bool IsDice(this BuiltInFunction entry) => entry == BuiltInFunction.Dice;
|
||
|
|
public static bool IsRound(this BuiltInFunction entry) => entry == BuiltInFunction.Round;
|
||
|
|
public static bool IsRoundPlaces(this BuiltInFunction entry) => entry == BuiltInFunction.RoundPlaces;
|
||
|
|
public static bool IsFloor(this BuiltInFunction entry) => entry == BuiltInFunction.Floor;
|
||
|
|
public static bool IsCeil(this BuiltInFunction entry) => entry == BuiltInFunction.Ceil;
|
||
|
|
public static bool IsInc(this BuiltInFunction entry) => entry == BuiltInFunction.Inc;
|
||
|
|
public static bool IsDec(this BuiltInFunction entry) => entry == BuiltInFunction.Dec;
|
||
|
|
public static bool IsDecimal(this BuiltInFunction entry) => entry == BuiltInFunction.Decimal;
|
||
|
|
public static bool IsInt(this BuiltInFunction entry) => entry == BuiltInFunction.Int;
|
||
|
|
public static bool IsUnknown(this BuiltInFunction entry) => entry == BuiltInFunction.Unknown;
|
||
|
|
|
||
|
|
// Lua name is the same as the Yarn name
|
||
|
|
public static string LuaName(this BuiltInFunction entry) => _luaNameMap[entry];
|
||
|
|
public static string YarnName(this BuiltInFunction entry) => _yarnNameMap[entry];
|
||
|
|
|
||
|
|
static BuiltInFunctionExt()
|
||
|
|
{
|
||
|
|
// Prepend 'ds_' to all built-in Yarn functions to create their Lua complements
|
||
|
|
var luaMap = (Dictionary<BuiltInFunction, string>)_luaNameMap;
|
||
|
|
foreach (var entry in _yarnNameMap) luaMap[entry.Key] = $"ds_{entry.Value}";
|
||
|
|
}
|
||
|
|
|
||
|
|
public static BuiltInFunction FromYarnSymbol(string symbol)
|
||
|
|
{
|
||
|
|
foreach (var entry in _yarnNameMap) if (entry.Value == symbol) return entry.Key;
|
||
|
|
return BuiltInFunction.Unknown;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
// + Enum: BuiltInOperator
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
public enum BuiltInOperator : int
|
||
|
|
{
|
||
|
|
Invalid,
|
||
|
|
Parentheses,
|
||
|
|
EqualTo,
|
||
|
|
GreaterThan,
|
||
|
|
GreaterThanOrEqualTo,
|
||
|
|
LessThan,
|
||
|
|
LessThanOrEqualTo,
|
||
|
|
NotEqualTo,
|
||
|
|
Or,
|
||
|
|
And,
|
||
|
|
Xor,
|
||
|
|
Not,
|
||
|
|
Assign,
|
||
|
|
UnaryMinus,
|
||
|
|
Add,
|
||
|
|
Minus,
|
||
|
|
Multiply,
|
||
|
|
Divide,
|
||
|
|
Modulo,
|
||
|
|
AddAssign,
|
||
|
|
MinusAssign,
|
||
|
|
MultiplyAssign,
|
||
|
|
DivideAssign,
|
||
|
|
}
|
||
|
|
|
||
|
|
public static partial class BuiltInOperatorExt
|
||
|
|
{
|
||
|
|
private static readonly IReadOnlyDictionary<string, BuiltInOperator> SymbolToBuiltInOperatorMap;
|
||
|
|
|
||
|
|
static BuiltInOperatorExt()
|
||
|
|
{
|
||
|
|
SymbolToBuiltInOperatorMap = new Dictionary<string, BuiltInOperator>
|
||
|
|
{
|
||
|
|
// OpenParens,
|
||
|
|
// CloseParens,
|
||
|
|
{ "()", BuiltInOperator.Parentheses },
|
||
|
|
|
||
|
|
// EqualTo, // ==, eq, is
|
||
|
|
// GreaterThan, // >, gt
|
||
|
|
// GreaterThanOrEqualTo, // >=, gte
|
||
|
|
// LessThan, // <, lt
|
||
|
|
// LessThanOrEqualTo, // <=, lte
|
||
|
|
// NotEqualTo, // !=, neq
|
||
|
|
{ "==", BuiltInOperator.EqualTo },
|
||
|
|
{ "eq", BuiltInOperator.EqualTo },
|
||
|
|
{ "is", BuiltInOperator.EqualTo },
|
||
|
|
{ ">", BuiltInOperator.GreaterThan },
|
||
|
|
{ "gt", BuiltInOperator.GreaterThan },
|
||
|
|
{ ">=", BuiltInOperator.GreaterThanOrEqualTo },
|
||
|
|
{ "gte", BuiltInOperator.GreaterThanOrEqualTo },
|
||
|
|
{ "<", BuiltInOperator.LessThan },
|
||
|
|
{ "lt", BuiltInOperator.LessThan },
|
||
|
|
{ "<=", BuiltInOperator.LessThanOrEqualTo },
|
||
|
|
{ "lte", BuiltInOperator.LessThanOrEqualTo },
|
||
|
|
{ "!=", BuiltInOperator.NotEqualTo },
|
||
|
|
{ "neq", BuiltInOperator.NotEqualTo },
|
||
|
|
|
||
|
|
// Logical operators
|
||
|
|
// Or, // ||, or
|
||
|
|
{ "||", BuiltInOperator.Or },
|
||
|
|
{ "or", BuiltInOperator.Or },
|
||
|
|
// And, // &&, and
|
||
|
|
{ "&&", BuiltInOperator.And },
|
||
|
|
{ "and", BuiltInOperator.And },
|
||
|
|
// Xor, // ^, xor
|
||
|
|
{ "^", BuiltInOperator.Xor },
|
||
|
|
{ "xor", BuiltInOperator.Xor },
|
||
|
|
// Not, // !, not
|
||
|
|
{ "!", BuiltInOperator.Not },
|
||
|
|
{ "not", BuiltInOperator.Not },
|
||
|
|
|
||
|
|
// Assign, // =, to
|
||
|
|
{ "=", BuiltInOperator.Assign },
|
||
|
|
{ "to", BuiltInOperator.Assign },
|
||
|
|
|
||
|
|
// Add, // +
|
||
|
|
{ "+", BuiltInOperator.Add },
|
||
|
|
// Minus, // -
|
||
|
|
{ "-", BuiltInOperator.Minus },
|
||
|
|
// Multiply, // *
|
||
|
|
{ "*", BuiltInOperator.Multiply },
|
||
|
|
// Divide, // /
|
||
|
|
{ "/", BuiltInOperator.Divide },
|
||
|
|
// Modulo, // %
|
||
|
|
{ "%", BuiltInOperator.Modulo },
|
||
|
|
|
||
|
|
// AddAssign, // +=
|
||
|
|
{ "+=", BuiltInOperator.AddAssign },
|
||
|
|
// MinusAssign, // -=
|
||
|
|
{ "-=", BuiltInOperator.MinusAssign },
|
||
|
|
// MultiplyAssign, // *=
|
||
|
|
{ "*=", BuiltInOperator.MultiplyAssign },
|
||
|
|
// DivideAssign, // /=
|
||
|
|
{ "/=", BuiltInOperator.DivideAssign },
|
||
|
|
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
public static BuiltInOperator FromYarnSymbol(string symbol)
|
||
|
|
{
|
||
|
|
if (!SymbolToBuiltInOperatorMap.ContainsKey(symbol)) return BuiltInOperator.Invalid;
|
||
|
|
|
||
|
|
return SymbolToBuiltInOperatorMap[symbol];
|
||
|
|
}
|
||
|
|
|
||
|
|
public static string LuaOperator(this BuiltInOperator op)
|
||
|
|
{
|
||
|
|
switch (op)
|
||
|
|
{
|
||
|
|
// Parentheses
|
||
|
|
case BuiltInOperator.Parentheses:
|
||
|
|
return "()";
|
||
|
|
|
||
|
|
// Arithmetic
|
||
|
|
case BuiltInOperator.Add:
|
||
|
|
return "+";
|
||
|
|
case BuiltInOperator.UnaryMinus:
|
||
|
|
case BuiltInOperator.Minus:
|
||
|
|
return "-";
|
||
|
|
case BuiltInOperator.Multiply:
|
||
|
|
return "*";
|
||
|
|
case BuiltInOperator.Divide:
|
||
|
|
return "/";
|
||
|
|
// I believe this requires Lua 5.1+, verify which one is used in DialogueSystem
|
||
|
|
case BuiltInOperator.Modulo:
|
||
|
|
return "%";
|
||
|
|
|
||
|
|
// UNSUPPORTED: Arithmetic Assignment
|
||
|
|
case BuiltInOperator.AddAssign:
|
||
|
|
// return "+";
|
||
|
|
return "<ADD ASSIGN (+=) OPERATOR NOT SUPPORTED, MODIFY YOUR CODE'S LOGIC>";
|
||
|
|
case BuiltInOperator.MinusAssign:
|
||
|
|
// return "-";
|
||
|
|
return "<SUBTRACT ASSIGN (-=) OPERATOR NOT SUPPORTED, MODIFY YOUR CODE'S LOGIC>";
|
||
|
|
case BuiltInOperator.MultiplyAssign:
|
||
|
|
// return "*";
|
||
|
|
return "<MULTIPLY ASSIGN (*=) OPERATOR NOT SUPPORTED, MODIFY YOUR CODE'S LOGIC>";
|
||
|
|
case BuiltInOperator.DivideAssign:
|
||
|
|
// return "/";
|
||
|
|
return "<DIVIDE ASSIGN (/=) OPERATOR NOT SUPPORTED, MODIFY YOUR CODE'S LOGIC>";
|
||
|
|
// I believe this requires Lua 5.1+, verify which one is used in DialogueSystem
|
||
|
|
// case BuiltInOperatorType.Modulo:
|
||
|
|
// return "%";
|
||
|
|
|
||
|
|
// NOTE: I have no idea why this is called EqualToOrAssign, which worries me.
|
||
|
|
// Shouldn't it just be called the Assign operator? I have to be missing something.
|
||
|
|
case BuiltInOperator.Assign:
|
||
|
|
// return "+";
|
||
|
|
return "=";
|
||
|
|
|
||
|
|
// Logical Operators
|
||
|
|
// Or, // ||, or
|
||
|
|
// And, // &&, and
|
||
|
|
// Xor, // ^, xor
|
||
|
|
// Not, // !, not
|
||
|
|
case BuiltInOperator.Or:
|
||
|
|
return "or";
|
||
|
|
case BuiltInOperator.And:
|
||
|
|
return "and";
|
||
|
|
case BuiltInOperator.Xor:
|
||
|
|
// return "<LOGICAL XOR OPERATOR NOT SUPPORTED, MODIFY YOUR CODE'S LOGIC>";
|
||
|
|
return "~=";
|
||
|
|
case BuiltInOperator.Not:
|
||
|
|
return "not";
|
||
|
|
|
||
|
|
// Relational Operators
|
||
|
|
case BuiltInOperator.EqualTo:
|
||
|
|
return "==";
|
||
|
|
case BuiltInOperator.GreaterThan:
|
||
|
|
return ">";
|
||
|
|
case BuiltInOperator.GreaterThanOrEqualTo:
|
||
|
|
return ">=";
|
||
|
|
case BuiltInOperator.LessThan:
|
||
|
|
return "<";
|
||
|
|
case BuiltInOperator.LessThanOrEqualTo:
|
||
|
|
return "<=";
|
||
|
|
case BuiltInOperator.NotEqualTo:
|
||
|
|
return "~=";
|
||
|
|
}
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static string Name(this BuiltInOperator op) => op.ToString();
|
||
|
|
|
||
|
|
public static bool IsUnary(this BuiltInOperator op) => op == BuiltInOperator.Not || op == BuiltInOperator.UnaryMinus;
|
||
|
|
public static bool IsBinary(this BuiltInOperator op) => !op.IsUnary();
|
||
|
|
public static bool IsInvalid(this BuiltInOperator entry) => entry == BuiltInOperator.Invalid;
|
||
|
|
public static bool IsParentheses(this BuiltInOperator entry) => entry == BuiltInOperator.Parentheses;
|
||
|
|
public static bool IsEqualTo(this BuiltInOperator entry) => entry == BuiltInOperator.EqualTo;
|
||
|
|
public static bool IsGreaterThan(this BuiltInOperator entry) => entry == BuiltInOperator.GreaterThan;
|
||
|
|
public static bool IsGreaterThanOrEqualTo(this BuiltInOperator entry) => entry == BuiltInOperator.GreaterThanOrEqualTo;
|
||
|
|
public static bool IsLessThan(this BuiltInOperator entry) => entry == BuiltInOperator.LessThan;
|
||
|
|
public static bool IsLessThanOrEqualTo(this BuiltInOperator entry) => entry == BuiltInOperator.LessThanOrEqualTo;
|
||
|
|
public static bool IsNotEqualTo(this BuiltInOperator entry) => entry == BuiltInOperator.NotEqualTo;
|
||
|
|
public static bool IsOr(this BuiltInOperator entry) => entry == BuiltInOperator.Or;
|
||
|
|
public static bool IsAnd(this BuiltInOperator entry) => entry == BuiltInOperator.And;
|
||
|
|
public static bool IsXor(this BuiltInOperator entry) => entry == BuiltInOperator.Xor;
|
||
|
|
public static bool IsNot(this BuiltInOperator entry) => entry == BuiltInOperator.Not;
|
||
|
|
public static bool IsAssign(this BuiltInOperator entry) => entry == BuiltInOperator.Assign;
|
||
|
|
public static bool IsUnaryMinus(this BuiltInOperator entry) => entry == BuiltInOperator.UnaryMinus;
|
||
|
|
public static bool IsAdd(this BuiltInOperator entry) => entry == BuiltInOperator.Add;
|
||
|
|
public static bool IsMinus(this BuiltInOperator entry) => entry == BuiltInOperator.Minus;
|
||
|
|
public static bool IsMultiply(this BuiltInOperator entry) => entry == BuiltInOperator.Multiply;
|
||
|
|
public static bool IsDivide(this BuiltInOperator entry) => entry == BuiltInOperator.Divide;
|
||
|
|
public static bool IsModulo(this BuiltInOperator entry) => entry == BuiltInOperator.Modulo;
|
||
|
|
public static bool IsAddAssign(this BuiltInOperator entry) => entry == BuiltInOperator.AddAssign;
|
||
|
|
public static bool IsMinusAssign(this BuiltInOperator entry) => entry == BuiltInOperator.MinusAssign;
|
||
|
|
public static bool IsMultiplyAssign(this BuiltInOperator entry) => entry == BuiltInOperator.MultiplyAssign;
|
||
|
|
public static bool IsDivideAssign(this BuiltInOperator entry) => entry == BuiltInOperator.DivideAssign;
|
||
|
|
}
|
||
|
|
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
// + Enum: CommandStringTokenType
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
public enum CommandStringTokenType : int
|
||
|
|
{
|
||
|
|
String,
|
||
|
|
Expression,
|
||
|
|
}
|
||
|
|
|
||
|
|
public static partial class CommandStringTokenTypeExt
|
||
|
|
{
|
||
|
|
public static bool IsString(this CommandStringTokenType entry) => entry == CommandStringTokenType.String;
|
||
|
|
public static bool IsExpression(this CommandStringTokenType entry) => entry == CommandStringTokenType.Expression;
|
||
|
|
}
|
||
|
|
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
// + Enum: ExpressionTokenType
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
public enum ExpressionTokenType : int
|
||
|
|
{
|
||
|
|
Bool,
|
||
|
|
Function,
|
||
|
|
Number,
|
||
|
|
Null,
|
||
|
|
Text,
|
||
|
|
Variable,
|
||
|
|
Operator,
|
||
|
|
}
|
||
|
|
|
||
|
|
public static partial class ExpressionTokenTypeExt
|
||
|
|
{
|
||
|
|
public static bool IsBool(this ExpressionTokenType entry) => entry == ExpressionTokenType.Bool;
|
||
|
|
public static bool IsFunction(this ExpressionTokenType entry) => entry == ExpressionTokenType.Function;
|
||
|
|
public static bool IsNumber(this ExpressionTokenType entry) => entry == ExpressionTokenType.Number;
|
||
|
|
public static bool IsNull(this ExpressionTokenType entry) => entry == ExpressionTokenType.Null;
|
||
|
|
public static bool IsText(this ExpressionTokenType entry) => entry == ExpressionTokenType.Text;
|
||
|
|
public static bool IsVariable(this ExpressionTokenType entry) => entry == ExpressionTokenType.Variable;
|
||
|
|
public static bool IsOperator(this ExpressionTokenType entry) => entry == ExpressionTokenType.Operator;
|
||
|
|
}
|
||
|
|
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
// + Enum: IfClauseType
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
public enum IfClauseType : int
|
||
|
|
{
|
||
|
|
If,
|
||
|
|
ElseIf,
|
||
|
|
Else,
|
||
|
|
}
|
||
|
|
|
||
|
|
public static partial class IfClauseTypeExt
|
||
|
|
{
|
||
|
|
public static bool IsIf(this IfClauseType entry) => entry == IfClauseType.If;
|
||
|
|
public static bool IsElseIf(this IfClauseType entry) => entry == IfClauseType.ElseIf;
|
||
|
|
public static bool IsElse(this IfClauseType entry) => entry == IfClauseType.Else;
|
||
|
|
}
|
||
|
|
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
// + Enum: StatementType
|
||
|
|
// +----------------------------------------------------------------------------
|
||
|
|
public enum StatementType : int
|
||
|
|
{
|
||
|
|
Call,
|
||
|
|
Command,
|
||
|
|
Declare,
|
||
|
|
Jump,
|
||
|
|
Line,
|
||
|
|
Set,
|
||
|
|
Conversation,
|
||
|
|
ShortcutOption,
|
||
|
|
ShortcutOptionList,
|
||
|
|
IfBlock,
|
||
|
|
IfClause,
|
||
|
|
}
|
||
|
|
|
||
|
|
public static partial class StatementTypeExt
|
||
|
|
{
|
||
|
|
private static HashSet<StatementType> BasicStatements = new HashSet<StatementType>
|
||
|
|
{
|
||
|
|
StatementType.Call,
|
||
|
|
StatementType.Command,
|
||
|
|
StatementType.Declare,
|
||
|
|
StatementType.Jump,
|
||
|
|
StatementType.Line,
|
||
|
|
StatementType.Set,
|
||
|
|
};
|
||
|
|
|
||
|
|
private static HashSet<StatementType> BlockStatements = new HashSet<StatementType>
|
||
|
|
{
|
||
|
|
StatementType.Conversation,
|
||
|
|
StatementType.ShortcutOption,
|
||
|
|
StatementType.ShortcutOptionList,
|
||
|
|
StatementType.IfBlock,
|
||
|
|
StatementType.IfClause,
|
||
|
|
};
|
||
|
|
|
||
|
|
public static bool IsBasic(this StatementType entry) => BasicStatements.Contains(entry);
|
||
|
|
public static bool IsBlock(this StatementType entry) => BlockStatements.Contains(entry);
|
||
|
|
|
||
|
|
public static bool IsCall(this StatementType entry) => entry == StatementType.Call;
|
||
|
|
public static bool IsCommand(this StatementType entry) => entry == StatementType.Command;
|
||
|
|
public static bool IsDeclare(this StatementType entry) => entry == StatementType.Declare;
|
||
|
|
public static bool IsJump(this StatementType entry) => entry == StatementType.Jump;
|
||
|
|
public static bool IsLine(this StatementType entry) => entry == StatementType.Line;
|
||
|
|
public static bool IsSet(this StatementType entry) => entry == StatementType.Set;
|
||
|
|
public static bool IsConversation(this StatementType entry) => entry == StatementType.Conversation;
|
||
|
|
public static bool IsShortcutOption(this StatementType entry) => entry == StatementType.ShortcutOption;
|
||
|
|
public static bool IsShortcutOptionList(this StatementType entry) => entry == StatementType.ShortcutOptionList;
|
||
|
|
public static bool IsIfBlock(this StatementType entry) => entry == StatementType.IfBlock;
|
||
|
|
public static bool IsIfClause(this StatementType entry) => entry == StatementType.IfClause;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|