public TypeDescriptor(Authentication authentication, IType type, DescriptorTypes descriptorTypes, object owner)
: base(authentication, type, descriptorTypes)
{
this.type = type;
this.owner = owner ?? this;
this.type.Dispatcher.VerifyAccess();
this.typeInfo = type.TypeInfo;
this.typeState = type.TypeState;
if (this.type.TypeInfo.IsFlag == true)
{
this.typeAttribute |= TypeAttribute.IsFlag;
}
this.lockInfo = type.LockInfo;
this.accessInfo = type.AccessInfo;
this.accessType = type.GetAccessType(this.authentication);
this.templateDescriptor = new TypeTemplateDescriptor(authentication, type.Template, descriptorTypes);
if (this.descriptorTypes.HasFlag(DescriptorTypes.IsSubscriptable) == true)
{
this.type.Deleted += Type_Deleted;
this.type.LockChanged += Type_LockChanged;
this.type.AccessChanged += Type_AccessChanged;
this.type.TypeInfoChanged += Type_TypeInfoChanged;
this.type.TypeStateChanged += Type_TypeStateChanged;
}
}
public void Start(TypeState typeState, DateTime dateTime)
{
OnTypeStart(new TyInfo(typeState), dateTime);
TypeData.Instance.TypeState = TypeState.Typing;
TypeData.Instance.StartTime = dateTime;
TypeData.Instance.GetTypeAchievement().AchievementDic["字数"].TypeData.关连值 = TypeData.Instance.TypeText.Length;
}
protected override TypeAttributeHandlerResult TryMap(AttributeMap item, TypeState s, TypeArgsValue a, RuntimeTypeModel model)
{
if (a.HasFamily(MetaType.AttributeFamily.Aqla) && CheckAqlaModelId(item, model))
{
var attr = item.GetRuntimeAttribute <SerializableTypeAttribute>(model);
s.SettingsValue = attr.TypeSettings;
s.ImplicitOnlyWriteable = attr.ImplicitOnlyWriteable;
s.DataMemberOffset = attr.DataMemberOffset;
if (attr.InferTagFromNameHasValue)
{
s.InferTagByName = attr.InferTagFromName;
}
s.ImplicitFields = attr.ImplicitFields;
if (attr.ImplicitFirstTag != 0)
{
s.ImplicitFirstTag = attr.ImplicitFirstTag;
}
if (s.ImplicitFields != ImplicitFieldsMode.None)
{
s.ImplicitAqla = true;
}
return(TypeAttributeHandlerResult.Done);
}
return(TypeAttributeHandlerResult.Continue);
}
private void Change(TypeState typeState)
{
foreach (var proxyMethod in typeState.ProxyMethods)
{
ChangeProxyMethod((BuildType)typeState.Type, proxyMethod);
}
}
/// <summary>
/// Gets the specified type.
/// </summary>
/// <param name="typeReference">The type reference.</param>
/// <returns></returns>
Type GetType(TypeReference typeReference, TypeState state)
{
Type type;
if (!types.TryGetValue(typeReference, out type))
{
type = BuildType(typeReference);
}
if (type == null)
{
return(null);
}
if ((state >= TypeState.StackComplete && type.StackType == StackValueType.Value) ||
state >= TypeState.TypeComplete)
{
CompleteType(type);
}
if (state >= TypeState.VTableEmitted)
{
GetClass(type);
}
return(type);
}
public ICreationContext MoveTo <TNewState>()
where TNewState : IStateDefinition <TSignal>
{
TypeState newTypeState = typeof(TNewState);
if (!CreationContext.States.TryGetValue(newTypeState, out var newState))
{
newState = CreationContext.Agent.CreateState <TNewState>();
CreationContext.States.Add(newTypeState, newState);
}
State.Transitions = (State.Transitions ?? new Transition <TypeState, TypeState> [0])
.Concat(new[]
{
new Transition <TypeState, TypeState>
{
Input = Input,
ResultantState = newTypeState,
Precondition = Precondition
}
}).ToArray();
return(CreationContext);
}
public TypeAttributeHandlerResult TryMap(AttributeMap item, TypeState s)
{
RuntimeTypeModel model = s.Model;
object tmp;
int tag = 0;
if (item.TryGet("tag", out tmp))
{
tag = (int)tmp;
}
Type knownType = null;
try
{
if (item.TryGet("knownTypeName", out tmp))
{
knownType = model.GetType((string)tmp, Helpers.GetAssembly(s.Type));
}
else if (item.TryGet("knownType", out tmp))
{
knownType = (Type)tmp;
}
}
catch (Exception ex)
{
throw new InvalidOperationException("Unable to resolve sub-type of: " + s.Type.FullName, ex);
}
if (knownType == null)
{
throw new InvalidOperationException("Unable to resolve sub-type of: " + s.Type.FullName);
}
s.DerivedTypes.Add(new DerivedTypeCandidate(tag, knownType));
return(TypeAttributeHandlerResult.Done);
}
protected override TypeAttributeHandlerResult TryMap(AttributeMap item, TypeState s, TypeArgsValue a, RuntimeTypeModel model)
{
if (a.CanUse(AttributeType.Aqla) && CheckAqlaModelId(item, model))
{
s.PartialMembers.Add(item);
}
return(TypeAttributeHandlerResult.Done);
}
protected override TypeAttributeHandlerResult TryMap(AttributeMap item, TypeState s, TypeArgsValue a, RuntimeTypeModel model)
{
if (a.CanUse(AttributeType.Aqla) && CheckAqlaModelId(item, model))
{
return(_derivedTypeStrategy.TryMap(item, s));
}
return(TypeAttributeHandlerResult.Continue);
}
public static State <TypeState, TypeState> CreateState <TState>()
where TState : IStateDefinition
{
var type = typeof(TState);
TypeState typeState = type;
var state = new State <TypeState, TypeState>
{
Value = typeState
};
var description = typeof(TState).GetCustomAttribute <DescriptionAttribute>(false)?.Description;
state.Description = description;
if (typeState.IsActionable() || typeState.IsPrecondition())
{
if (typeState.IsActionable())
{
string actionDescription = null;
var naturalActionInterface = type.GetInterfaces()
.FirstOrDefault(i => i.IsGenericType &&
i.GetGenericTypeDefinition() ==
typeof(INaturalAction <>));
if (naturalActionInterface != null)
{
var invokeMethodInfo = type.GetMethod(nameof(INaturalAction <object> .InvokeAsync),
new[]
{
typeof(ConnectorContext),
naturalActionInterface.GenericTypeArguments[0],
typeof(CancellationToken)
});
actionDescription = invokeMethodInfo?.GetCustomAttribute <DescriptionAttribute>()?.Description;
}
state.Action = new REstate.Schematics.Action <TypeState>
{
ConnectorKey = typeState.GetConnectorKey(),
Description = actionDescription
};
}
if (typeState.IsPrecondition())
{
state.Precondition = new Precondition
{
ConnectorKey = typeState.GetConnectorKey()
}
}
;
}
return(state);
}
public static ResultState <TItem> GetResultState(ISchemaStore schemas, TableIdentity heading)
{
return((ResultState <TItem>)factoryMap.GetOrAdd(heading, _ =>
{
TypeState state = GetTypeState(schemas);
return new ResultCompiler(state).Compile <TItem>(heading);
}));
}
public void ToggleUnit()
{
if (!UIToggle.current.value)
return;
_stateCont.GetController<SelectController>().Deselect();
_stateCont.GetController<SelectController>().ControllerSelectType = SelectController.SelectState.Mob;
_stateCont.ControllerState = ControllerState.Selection;
_typeState = TypeState.Mob;
}
internal void StartsIn <TState>()
where TState : IStateDefinition
{
TypeState typeState = typeof(TState);
var state = Agent.CreateState <TState>();
States.Add(typeState, state);
_schematic.InitialState = typeState;
}
private void txtType_TextChanged(object sender, TextChangedEventArgs e)
{
if (_state == TypeState.Restarted)
{
_state = TypeState.Playing;
_stopWatch.Restart();
}
ColorWord();
UpdateStats();
}
protected override TypeAttributeHandlerResult TryMap(AttributeMap item, TypeState s, TypeArgsValue a, RuntimeTypeModel model)
{
// we check CanUse everywhere but not family because GetContractFamily is based on CanUse
// and CanUse is based on the settings
// except is for SerializableAttribute which family is not returned if other families are present
if (a.HasFamily(MetaType.AttributeFamily.SystemSerializable))
{
s.ImplicitFields = ImplicitFieldsMode.AllFields;
s.ImplicitAqla = true;
}
return(TypeAttributeHandlerResult.Done);
}
public GrpcStateEngine(
IStateMachineService stateMachineService,
IEnumerable <IEventListener> listeners)
{
_stateMachineService = stateMachineService
.WithHeaders(new Metadata
{
{ "Status-Type", TypeState.FromType(typeof(TState)).GetFullName() },
{ "Input-Type", TypeState.FromType(typeof(TInput)).GetFullName() }
});
_listeners = listeners.ToList();
}
internal TypeState GetType(IType type)
{
type = type.DeclaringType;
TypeState state;
if (!_types.TryGetValue(type, out state))
{
state = new TypeState(type);
_types.Add(type, state);
}
return(state);
}
TypeState CreateTypeState(DmdType type, DbgLanguage language)
{
var info = GetDisplayParts(type);
if (info.nameParts.Length == 0 && info.valueParts.Length == 0 && info.typeParts.Length == 0)
{
return(TypeState.Empty);
}
var context = language.CreateContext(evalInfo.Runtime, null);
var state = new TypeState(context, info.nameParts, info.valueParts, info.typeParts);
context.Runtime.CloseOnExit(state);
return(state);
}
TypeState CreateTypeState(DmdType type, DbgLanguage language)
{
var parts = GetDisplayParts(type) ?? Array.Empty <DisplayPart>();
if (parts.Length == 0)
{
return(TypeState.Empty);
}
var context = language.CreateContext(frame.Runtime, null, cancellationToken: cancellationToken);
var state = new TypeState(context, parts);
context.Runtime.CloseOnExit(state);
return(state);
}
protected override TypeAttributeHandlerResult TryMap(AttributeMap item, TypeState s, TypeArgsValue a, RuntimeTypeModel model)
{
if (a.HasFamily(MetaType.AttributeFamily.DataContractSerialier))
{
var main = s.SettingsValue;
object tmp;
if (main.Name == null && item.TryGet("Name", out tmp))
{
main.Name = (string)tmp;
}
s.SettingsValue = main;
return(TypeAttributeHandlerResult.Done);
}
return(TypeAttributeHandlerResult.Continue);
}
public TypeTreeViewItemViewModel(CremaDataType dataType, ISelector selector)
{
this.Target = dataType;
this.dataType = dataType;
this.dataType.ExtendedProperties[selector] = this;
this.selector = selector;
this.typeInfo = dataType.TypeInfo;
this.typeAttribute = TypeAttribute.None;
this.typeState = TypeState.None;
this.renameCommand = new DelegateCommand(async() => await this.RenameAsync());
this.deleteCommand = new DelegateCommand(async() => await this.DeleteAsync());
this.viewCommand = new DelegateCommand(async() => await this.ViewContentAsync());
this.dataType.PropertyChanged += DataType_PropertyChanged;
this.Items.CollectionChanged += Items_CollectionChanged;
}
bool Format(DbgDotNetValue value, TypeState typeState, DisplayPart[] displayParts)
{
if (displayParts.Length == 0)
{
return(false);
}
var evaluator = evalInfo.Context.GetDebuggerDisplayAttributeEvaluator();
foreach (var part in displayParts)
{
if ((part.Flags & DisplayPartFlags.EvaluateText) == 0)
{
output.Write(DbgTextColor.DebuggerDisplayAttributeEval, part.Text);
}
else
{
var eeState = typeState.GetExpressionEvaluatorState(evalInfo.Context.Language.ExpressionEvaluator, part.Text);
DbgDotNetEvalResult evalRes = default;
try {
var evalInfo2 = new DbgEvaluationInfo(typeState.TypeContext !, evalInfo.Frame, evalInfo.CancellationToken);
evalRes = evaluator.Evaluate(evalInfo2, value, part.Text, DbgEvaluationOptions.Expression, eeState);
if (evalRes.Error is not null)
{
output.Write(DbgTextColor.Error, "<<<");
output.Write(DbgTextColor.Error, evalRes.Error);
output.Write(DbgTextColor.Error, ">>>");
}
else
{
// Prevent recursive calls
var options = this.options | DbgValueFormatterOptions.NoDebuggerDisplay;
options &= ~DbgValueFormatterOptions.NoStringQuotes;
options = PredefinedFormatSpecifiers.GetValueFormatterOptions(evalRes.FormatSpecifiers, options);
languageFormatter.FormatValue(evalInfo, output, evalRes.Value !, options, cultureInfo);
}
}
finally {
if (evalRes.Value != value)
{
evalRes.Value?.Dispose();
}
}
}
}
return(true);
}
public IForStateContext <TState> For <TState>()
where TState : IStateDefinition
{
TypeState typeState = typeof(TState);
if (!States.TryGetValue(typeState, out var state))
{
state = Agent.CreateState <TState>();
States.Add(typeState, state);
}
return(new ForStateContext <TState> {
CreationContext = this, State = state
});
}
public IWhenContext <TState, TSignal> When <TPrecondition>()
where TPrecondition : INaturalPrecondition <TSignal>
{
TypeState preconditionTypeState = typeof(TPrecondition);
return(new WhenContext <TState, TSignal>
{
CreationContext = CreationContext,
State = State,
Input = Input,
Precondition = new Precondition
{
ConnectorKey = preconditionTypeState.GetConnectorKey()
}
});
}
/// <summary>
/// Gets the specified type.
/// </summary>
/// <param name="typeReference">The type reference.</param>
/// <returns></returns>
Type GetType(TypeReference typeReference, TypeState state)
{
Type type;
if (!types.TryGetValue(typeReference, out type))
type = BuildType(typeReference);
if (type == null)
return null;
if ((state >= TypeState.StackComplete && type.StackType == StackValueType.Value)
|| state >= TypeState.TypeComplete)
CompleteType(type);
if (state >= TypeState.VTableEmitted)
GetClass(type);
return type;
}
public IConsume(IConsume item)
{
RemoveAllState = item.RemoveAllState;
AddState = item.AddState;
RemoveState = item.RemoveState;
AddTrait = item.AddTrait;
RemoveTrait = item.RemoveTrait;
Stats = item.Stats;
Recover = item.Recover;
Name = item.Name;
Icon = item.Icon;
Category = item.Category;
Description = item.Description;
Value = item.Value;
Stack = item.Stack;
}
public IWhenContext <TState, TSignal> When <TPrecondition>()
where TPrecondition : INaturalPrecondition <TSignal>
{
TypeState preconditionTypeState = typeof(TPrecondition);
CreationContext.Agent.Configuration.Register(registrar =>
registrar.RegisterConnector(preconditionTypeState)
.WithConfiguration(new ConnectorConfiguration(preconditionTypeState.GetConnectorKey())));
return(new WhenContext <TState, TSignal>
{
CreationContext = CreationContext,
State = State,
Input = Input,
Precondition = new Precondition
{
ConnectorKey = preconditionTypeState.GetConnectorKey()
}
});
}
// void Start()
// {
// // game_variables.Instance.IsSave;
// // _isSave = PlayerPrefs.GetInt("save", 0) == 0 ? false : true;
// }
public void Save(string id, base_state state, TypeState type)
{
//
FileStream file = new FileStream(Application.persistentDataPath + "/" + type.ToString() + "/" + id + ".dot", FileMode.OpenOrCreate);
try
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(file, state);
}
catch (SerializationException e)
{
feedback_toaster.Instance.RegisterMessage(gameObject.name + " : " + e.Message, game_variables.Instance.ColorDefault);
}
finally
{
file.Close();
game_variables.Instance.Save();
}
}
public IThrow(IThrow item)
{
Battle = item.Battle;
Piercing = item.Piercing;
Piercing_Precent = item.Piercing_Precent;
AttackElement = item.AttackElement;
AtkState = item.AtkState;
RemoveState = item.RemoveState;
RemoveAllState = item.RemoveAllState;
MissileFlight = item.MissileFlight;
AreaRange = item.AreaRange;
AreaAttack = item.AreaAttack;
IgnoreObstacle = item.IgnoreObstacle;
Name = item.Name;
Icon = item.Icon;
Category = item.Category;
Description = item.Description;
Value = item.Value;
Stack = item.Stack;
}
private static TypeState GetTypeState(ISchemaStore schemas)
{
if (typeState != null)
{
return(typeState);
}
lock (typeLock)
{
if (typeState != null)
{
return(typeState);
}
Type listType = typeof(IList <>).MakeGenericType(typeof(TItem));
ISchema schema = schemas.GetSchema(listType);
return(typeState = new TypeState(schema));
}
}
/// <summary>
/// Registers an <see cref="IAction{TState,TInput}"/> or <see cref="IPrecondition{TState,TInput}"/>.
/// </summary>
/// <param name="registrar"></param>
/// <param name="connectorType">
/// The unbound generic type of the connector aka generic type definition. e.g.
/// <c>typeof(LoggingAction<,>)</c>
/// </param>
/// <param name="registrationName">
/// The name to register the type as in the <see cref="IComponentContainer"/>.
/// <para />
/// Registration names should ALWAYS be unique, overriding is NOT supported for safety/clarity reasons.
/// <para />
/// The default is the assembly qualified name of the type.
/// </param>
/// <returns>A <see cref="IConnectorRegistration"/> that allows the caller to
/// register an <see cref="IConnectorConfiguration"/> that includes an Identifier
/// that can be resolved using a <see cref="Schematics.ConnectorKey"/> in a <see cref="Schematics.ISchematic{TState,TInput}"/>.
/// </returns>
/// <remarks>
/// Connectors are available for use by a <see cref="IStateMachine{TState,TInput}"/> when a <see cref="Schematics.ConnectorKey"/>
/// in its <see cref="Schematics.ISchematic{TState,TInput}"/> matches a <see cref="IConnectorConfiguration"/>,
/// that has been registered in a <see cref="IConnectorRegistration"/>'s <c>WithConfiguration</c> method.
/// </remarks>
public static IConnectorRegistration RegisterConnector(
this IRegistrar registrar,
Type connectorType,
string registrationName = null)
{
var registrationKey = registrationName ?? TypeState.FromType(connectorType).GetConnectorKey();
var interfaces = connectorType
.GetInterfaces()
.Where(type => type.IsConstructedGenericType)
.Select(type => type.GetGenericTypeDefinition())
.ToList();
var registered = false;
if (interfaces.Any(type => type == typeof(IAction <,>)))
{
registrar.Register(typeof(IAction <,>), connectorType, registrationKey);
registered = true;
}
if (interfaces.Any(type => type == typeof(IPrecondition <,>)))
{
registrar.Register(typeof(IPrecondition <,>), connectorType, registrationKey);
registered = true;
}
if (!registered)
{
throw new ArgumentException(
message: "Type must be either IAction<,> or IPrecondition<,> to be registered.",
paramName: nameof(connectorType));
}
return(new ConnectorRegistration(registrar, connectorType));
}
private void Restart()
{
txtType.IsReadOnly = false;
_state = TypeState.Restarted;
_wordIndex = 0;
var words = _text.Split(' ');
_words.Clear();
var position = 0;
for (int i = 0; i < words.Length; i++)
{
_words.Add(new Word(words[i], position));
position += words[i].Length + 1;
}
txtText.Text = _text;
txtType.Text = string.Empty;
txtType.Focus();
ColorWord();
}
public State(Program handle,TypeState type, int timerIntervalMilliseconds=100)
{
_MainHandle = handle;
_typeState = type;
_timerIntervalMilliseconds = timerIntervalMilliseconds;
}
public State(TypeState type)
{
_typeState = type;
}