/// <summary>
/// Creates an instance of the attribute
/// </summary>
/// <param name="name">Display Name for the Addin</param>
/// <param name="description">Description for the Addin</param>
/// <param name="loadBehavior">LoadBehavior for the Addin</param>
public COMAddinAttribute(string name, string description, LoadBehavior loadBehavior)
{
Name = name;
Description = description;
LoadBehavior = Convert.ToInt32(loadBehavior);
CommandLineSafe = -1;
}
internal Level(string n, LoadBehavior loadBehavior, Behavior updateBehavior,
Behavior endBehavior, Condition winCondition)
{
mName = n;
LoadBehavior = loadBehavior;
UpdateBehavior = updateBehavior;
EndBehavior = endBehavior;
WinCondition = winCondition;
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadResult{TEntity}"/> class.
/// </summary>
/// <param name="query">The entity query which was completed.</param>
/// <param name="loadBehavior">The load behavior used for load.</param>
/// <param name="entities">Top level entities loaded.</param>
/// <param name="allEntities">All entities loaded.</param>
/// <param name="totalEntityCount">The total entity count.</param>
public LoadResult(EntityQuery <TEntity> query, LoadBehavior loadBehavior, IEnumerable <TEntity> entities, IReadOnlyCollection <Entity> allEntities, int totalEntityCount)
{
_loadedEntites = (entities as Data.ReadOnlyObservableLoaderCollection <TEntity>) ?? new Data.ReadOnlyObservableLoaderCollection <TEntity>(entities.ToList());
EntityQuery = query;
LoadBehavior = loadBehavior;
AllEntities = allEntities;
TotalEntityCount = totalEntityCount;
}
public override LoadOperation Load(EntityQuery query, LoadBehavior loadBehavior, Action <LoadOperation> callback, object userState)
{
if (this._loadCallback != null)
{
this._loadCallback(query, loadBehavior, userState);
}
return(base.Load(query, loadBehavior, callback, userState));
}
internal FrostbyteLevel(string n, LoadBehavior loadBehavior, Behavior updateBehavior,
Behavior endBehavior, Condition winCondition = null)
: base(n, loadBehavior, updateBehavior, endBehavior, winCondition)
{
if (winCondition == null)
{
WinCondition = delegate() { return(LevelCompleted); };
}
}
internal ExportDefinition(string application, string baseDirectory, string entryPoint, string entryPoint32, string entryPoint64, LoadBehavior loadBehavior)
{
Application = application;
_entryPoint = entryPoint;
_entryPoint32 = entryPoint32;
_entryPoint64 = entryPoint64;
BaseDirectory = baseDirectory;
LoadBehavior = loadBehavior;
}
public override LoadOperation Load(EntityQuery query, LoadBehavior loadBehavior, Action<LoadOperation> callback, object userState)
{
if (this._loadCallback != null)
{
this._loadCallback(query, loadBehavior, userState);
}
return base.Load(query, loadBehavior, callback, userState);
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadOperation"/> class.
/// </summary>
/// <param name="query">The query to load.</param>
/// <param name="loadBehavior"><see cref="LoadBehavior"/> to use for the load operation.</param>
/// <param name="userState">Optional user state for the operation.</param>
/// <param name="supportCancellation"><c>true</c> to enable <see cref="OperationBase.CancellationToken"/> to be cancelled when <see cref="OperationBase.Cancel"/> is called</param>
private protected LoadOperation(EntityQuery query, LoadBehavior loadBehavior, object userState, bool supportCancellation)
: base(userState, supportCancellation)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
this._query = query;
this._loadBehavior = loadBehavior;
}
public virtual LoadBehavior GetLoadBehavior(IClassMap classMap)
{
LoadBehavior loadBehavior = classMap.GetLoadBehavior();
if (loadBehavior == LoadBehavior.Default)
{
loadBehavior = this.Context.LoadBehavior;
}
return(loadBehavior);
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadOperation"/> class.
/// </summary>
/// <param name="query">The query to load.</param>
/// <param name="loadBehavior"><see cref="LoadBehavior"/> to use for the load operation.</param>
/// <param name="userState">Optional user state for the operation.</param>
internal LoadOperation(EntityQuery query, LoadBehavior loadBehavior, object userState)
: base(userState)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
this._query = query;
this._loadBehavior = loadBehavior;
}
/// <summary>
/// Applies the specified state to the specified object taking the specified LoadBehavior into account.
/// </summary>
/// <param name="o">The object to apply state to.</param>
/// <param name="stateToApply">The state dictionary.</param>
/// <param name="originalState">The original state map for the modified object.</param>
/// <param name="loadBehavior">The LoadBehavior to govern property merge behavior.</param>
internal static void ApplyState(object o, IDictionary<string, object> stateToApply, IDictionary<string, object> originalState, LoadBehavior loadBehavior)
{
if (loadBehavior == LoadBehavior.KeepCurrent)
{
return;
}
MetaType metaType = MetaType.GetMetaType(o.GetType());
bool isMerging = (o as Entity) == null ? (o as ComplexObject) != null && (o as ComplexObject).IsMergingState : (o as Entity).IsMergingState;
foreach (MetaMember metaMember in metaType.DataMembers)
{
PropertyInfo propertyInfo = metaMember.Member;
object newValue;
if ((isMerging && metaMember.IsMergable || !isMerging) && stateToApply.TryGetValue(propertyInfo.Name, out newValue))
{
if (newValue != null && metaMember.IsComplex && !metaMember.IsCollection)
{
object currValue = propertyInfo.GetValue(o, null);
IDictionary<string, object> newValueState = (IDictionary<string, object>)newValue;
if (currValue != null)
{
// if the current and new values are both non-null, we have to do a merge
object complexTypeOriginalValues = null;
if (originalState != null)
{
originalState.TryGetValue(propertyInfo.Name, out complexTypeOriginalValues);
}
ApplyState(currValue, newValueState, (IDictionary<string, object>)complexTypeOriginalValues, loadBehavior);
}
else
{
// We do this lazy to avoid rehydrating the instance if we don't have to
Lazy<object> lazy = new Lazy<object>(
delegate
{
// Rehydrate an instance from the state dictionary.
object newInstance = Activator.CreateInstance(propertyInfo.PropertyType);
ApplyState(newInstance, newValueState);
return newInstance;
});
ApplyValue(o, lazy, propertyInfo, originalState, loadBehavior);
}
}
else
{
ApplyValue(o, newValue, propertyInfo, originalState, loadBehavior);
}
}
} // end foreach
}
public void Load(EntityQuery query, LoadBehavior loadBehavior)
{
Action <LoadOperation> callback = delegate(LoadOperation lo)
{
if (lo.HasError)
{
lo.MarkErrorAsHandled();
}
};
this.loadOperation = this.ctxt.Load(query, loadBehavior, callback, null);
}
public void OutputXml(XmlWriter writer)
{
writer.WriteStartElement("visio", "PublishAddin", "http://schemas.microsoft.com/wix/Visio");
if (ProgId != null)
{
writer.WriteAttributeString("ProgId", ProgId);
}
if (FriendlyName != null)
{
writer.WriteAttributeString("FriendlyName", FriendlyName);
}
if (Description != null)
{
writer.WriteAttributeString("Description", Description);
}
writer.WriteAttributeString("CommandLineSafe", CommandLineSafe != 0 ? "yes" : "no");
writer.WriteAttributeString("LoadBehavior", LoadBehavior.ToString());
switch ((VisioEdition)VisioEditionAttribute)
{
case VisioEdition.X86:
writer.WriteAttributeString("VisioEdition", "x86");
break;
case VisioEdition.X64:
writer.WriteAttributeString("VisioEdition", "x64");
break;
}
switch ((AddinType)Type)
{
case AddinType.COM:
writer.WriteAttributeString("Type", "COM");
break;
case AddinType.VSTO:
writer.WriteAttributeString("Type", "VSTO");
break;
}
writer.WriteEndElement();
}
private ExportDefinition ReadExport(XmlReader reader, string baseDirectory)
{
//Move to <Export> element
MoveToElement(reader, ExportElementName);
//Prepare Export properties
string application = string.Empty;
string entryPoint = string.Empty;
string entryPoint32 = string.Empty;
string entryPoint64 = string.Empty;
LoadBehavior loadBehavior = LoadBehavior.OnDemand;
//Read Export attributes
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case ApplicationAttributeName:
application = reader.ReadContentAsString();
break;
case EntryPointAttributeName:
entryPoint = reader.ReadContentAsString();
break;
case EntryPoint32AttributeName:
entryPoint32 = reader.ReadContentAsString();
break;
case EntryPoint64AttributeName:
entryPoint64 = reader.ReadContentAsString();
break;
case LoadBehaviorAttributeName:
loadBehavior = reader.ReadContentAsEnum <LoadBehavior>();
break;
}
}
//Move back to <Export> element
reader.MoveToElement();
ExportDefinition definition = new ExportDefinition(application, baseDirectory, entryPoint, entryPoint32, entryPoint64, loadBehavior);
return(definition);
}
/// <summary>
/// Creates a strongly typed <see cref="LoadOperation"/> for the specified Type.
/// </summary>
/// <typeparam name="TEntity">The entity Type.</typeparam>
/// <param name="query">The query to load.</param>
/// <param name="loadBehavior"><see cref="LoadBehavior"/> to use for the load operation.</param>
/// <param name="completeAction">Action to execute when the operation completes.</param>
/// <param name="userState">Optional user state for the operation.</param>
/// <param name="cancelAction">Action to execute when the operation is canceled. If null, cancellation will not be supported.</param>
/// <returns>The operation instance created.</returns>
internal static LoadOperation Create <TEntity>(EntityQuery <TEntity> query, LoadBehavior loadBehavior,
Action <LoadOperation> completeAction, object userState,
Action <LoadOperation> cancelAction) where TEntity : Entity
{
Action <LoadOperation <TEntity> > wrappedCompleteAction = null;
Action <LoadOperation <TEntity> > wrappedCancelAction = null;
if (completeAction != null)
{
wrappedCompleteAction = arg => completeAction(arg);
}
if (cancelAction != null)
{
wrappedCancelAction = arg => cancelAction(arg);
}
return(new LoadOperation <TEntity>(query, loadBehavior, wrappedCompleteAction, userState, wrappedCancelAction));
}
/// <summary>
/// Method that synchronizes the current graph with the provided graph by copying properties and entity states
/// from the entities in give graph to the current graph. The way that property values are merged is specified by loadBehavior.
/// </summary>
/// <param name="srcGraph">The graph to synchronize from</param>
/// <param name="loadBehavior">The LoadBehavior to apply. When specifying LoadBehavior.KeepCurrent, Synchronize will have no effect.</param>
public void Synchronize(EntityGraph srcGraph, LoadBehavior loadBehavior)
{
if (loadBehavior == LoadBehavior.KeepCurrent)
{
return;
}
if (loadBehavior == LoadBehavior.RefreshCurrent)
{
Synchronize(srcGraph);
}
if (EntityGraphEqual(srcGraph, EntityTypeComparer) == false)
{
throw new Exception("Source graph entity graph must be a copy or a clone of present entity graph.");
}
var elements = srcGraph.Zip(this, (src, tgt) => new { src = src, tgt = tgt });
foreach (var pair in elements)
{
MergeIntoCurrent(pair.src, pair.tgt);
}
}
/// <summary>
/// Load the specified collection of entities into this <see cref="EntityContainer"/>.
/// </summary>
/// <param name="entities">The entities to load</param>
/// <param name="loadBehavior">The <see cref="LoadBehavior"/> to use</param>
/// <returns>The set of entities loaded. In cases where entities in the set
/// are already cached locally, the return set will contain the cached instances.</returns>
public IEnumerable LoadEntities(IEnumerable entities, LoadBehavior loadBehavior)
{
if (entities == null)
{
throw new ArgumentNullException("entities");
}
// group the entities by type, and load each group into it's entity
// list (ensuring we don't modify the relative ordering of each sequence
// of results per type). We group by root entity type so that all derived
// entities belong to the same group.
List <Entity> loadedEntities = new List <Entity>();
var entityGroups = entities.Cast <Entity>().GroupBy(p => (this.GetEntitySet(p.GetType())));
foreach (var group in entityGroups)
{
EntitySet set = group.Key;
loadedEntities.AddRange(set.LoadEntities(group, loadBehavior));
}
return(loadedEntities);
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadingDataEventArgs"/> class.
/// </summary>
/// <param name="query">Default query that will be used for the load operation</param>
/// <param name="loadBehavior">Default load behavior that will be used for the load operation</param>
internal LoadingDataEventArgs(EntityQuery query, LoadBehavior loadBehavior)
{
this.Query = query;
this.LoadBehavior = loadBehavior;
this.RestoreLoadSettings = true;
}
private void ApplyState(IDictionary<string, object> entityStateToApply, LoadBehavior loadBehavior)
{
if (loadBehavior == LoadBehavior.KeepCurrent)
{
return;
}
try
{
// We use this state to suppress validation during property sets
this._isApplyingState = true;
ObjectStateUtility.ApplyState(this, entityStateToApply, this._originalValues, loadBehavior);
}
catch (TargetInvocationException tie)
{
if (tie.InnerException != null)
{
throw tie.InnerException;
}
throw;
}
finally
{
this._isApplyingState = false;
}
}
/// <summary>
/// Merge differs from ApplyState in that its the merge of an entire
/// entity as opposed to an arbitrary set (possibly subset) of values.
/// Change tracking is suspended for the entity during the merge.
/// </summary>
/// <param name="otherEntity">The entity to merge into the current instance</param>
/// <param name="loadBehavior">The load behavior to use</param>
internal void Merge(Entity otherEntity, LoadBehavior loadBehavior)
{
if (loadBehavior == LoadBehavior.KeepCurrent)
{
return;
}
// set this flag so change tracking and edit enforcement
// is suspended during the merge
this._isMerging = true;
IDictionary<string, object> otherState = otherEntity.ExtractState();
this.ApplyState(otherState, loadBehavior);
// after the merge update our original state based on the
// load behavior selected
if (this._originalValues != null)
{
if (loadBehavior == LoadBehavior.RefreshCurrent)
{
// when refreshing, the entity should no longer be
// considered modfied, so we wipe out original values
this._originalValues = null;
if (this.EntityState == EntityState.Modified && this.CustomMethodInvocation == null && !this.HasChildChanges)
{
// we've just reverted all property edits. If we're not modified for
// any other reason, transition to Unmodified
this.EntityState = EntityState.Unmodified;
}
}
else
{
this._originalValues = otherState;
}
}
this._isMerging = false;
this.OnLoaded(false);
}
public static void LoadAllScripts(AddBehavior existsAlready = AddBehavior.Ignore,
LoadBehavior alreadyLoaded = LoadBehavior.Reload)
{
CheckSetUp();
_LoadScripts(_scriptList.Keys, alreadyLoaded);
}
/// <summary>
/// Helepr method to invoke generic LoadAsync when the type of the result is not known at compile time
/// </summary>
private async Task <ILoadResult> LoadAsyncHelper <T>(EntityQuery <T> query, LoadBehavior loadBehavior, CancellationToken cancellationToken)
where T : Entity
{
return(await this.DomainContext.LoadAsync(query, loadBehavior, cancellationToken));
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadingDataEventArgs"/> class.
/// </summary>
/// <param name="query">Default query that will be used for the load operation</param>
/// <param name="loadBehavior">Default load behavior that will be used for the load operation</param>
internal LoadingDataEventArgs(EntityQuery query, LoadBehavior loadBehavior)
{
this.Query = query;
this.LoadBehavior = loadBehavior;
this.RestoreLoadSettings = true;
}
/// <summary>
/// 初始化 <see cref="RelationOptions"/> 类的新实例。
/// </summary>
/// <param name="loadBehavior">加载行为。</param>
public RelationOptions(LoadBehavior loadBehavior)
{
LoadBehavior = loadBehavior;
}
/// <summary>
/// Applies the specified state to the specified object taking the specified LoadBehavior into account.
/// </summary>
/// <param name="o">The object to apply state to.</param>
/// <param name="stateToApply">The state dictionary.</param>
/// <param name="originalState">The original state map for the modified object.</param>
/// <param name="loadBehavior">The LoadBehavior to govern property merge behavior.</param>
internal static void ApplyState(object o, IDictionary <string, object> stateToApply, IDictionary <string, object> originalState, LoadBehavior loadBehavior)
{
if (loadBehavior == LoadBehavior.KeepCurrent)
{
return;
}
MetaType metaType = MetaType.GetMetaType(o.GetType());
bool isMerging = (o as Entity) == null ? (o as ComplexObject) != null && (o as ComplexObject).IsMergingState : (o as Entity).IsMergingState;
foreach (MetaMember metaMember in metaType.DataMembers)
{
object newValue;
if ((isMerging && metaMember.IsMergable || !isMerging) && stateToApply.TryGetValue(metaMember.Name, out newValue))
{
if (newValue != null && metaMember.IsComplex && !metaMember.IsCollection)
{
object currValue = metaMember.GetValue(o);
IDictionary <string, object> newValueState = (IDictionary <string, object>)newValue;
if (currValue != null)
{
// if the current and new values are both non-null, we have to do a merge
object complexTypeOriginalValues = null;
if (originalState != null)
{
originalState.TryGetValue(metaMember.Name, out complexTypeOriginalValues);
}
ApplyState(currValue, newValueState, (IDictionary <string, object>)complexTypeOriginalValues, loadBehavior);
}
else
{
// We do this lazy to avoid rehydrating the instance if we don't have to
Lazy <object> lazy = new Lazy <object>(
delegate
{
// Rehydrate an instance from the state dictionary.
object newInstance = Activator.CreateInstance(metaMember.PropertyType);
ApplyState(newInstance, newValueState);
return(newInstance);
});
ApplyValue(o, lazy, metaMember, originalState, loadBehavior);
}
}
else
{
ApplyValue(o, newValue, metaMember, originalState, loadBehavior);
}
}
} // end foreach
}
internal Level(string n, LoadBehavior loadBehavior, Behavior updateBehavior,
Behavior endBehavior, Condition winCondition)
{
mName = n;
LoadBehavior = loadBehavior;
UpdateBehavior = updateBehavior;
EndBehavior = endBehavior;
WinCondition = winCondition;
}
/// <summary>
/// Method used to apply a value taking the specified LoadBehavior into account.
/// </summary>
/// <param name="o">The target object</param>
/// <param name="value">The value to apply</param>
/// <param name="propertyInfo">The property to apply the value to</param>
/// <param name="originalState">The original state map for the object</param>
/// <param name="loadBehavior">The LoadBehavior to govern property merge behavior.</param>
private static void ApplyValue(object o, object value, PropertyInfo propertyInfo, IDictionary<string, object> originalState, LoadBehavior loadBehavior)
{
if (loadBehavior == LoadBehavior.KeepCurrent)
{
return;
}
Lazy<object> lazyValue = value as Lazy<object>;
if (loadBehavior == LoadBehavior.RefreshCurrent)
{
// overwrite value with the new value
if (lazyValue != null)
{
value = lazyValue.Value;
}
propertyInfo.SetValue(o, value, null);
}
else if (loadBehavior == LoadBehavior.MergeIntoCurrent)
{
if (!PropertyHasChanged(o, originalState, propertyInfo))
{
// set the value only if our value hasn't been modified
if (lazyValue != null)
{
value = lazyValue.Value;
}
propertyInfo.SetValue(o, value, null);
}
}
}
public void MissingAttribute(IQueryable<City> query, LoadBehavior loadBehavior, object userState)
{
}
/// <summary>
/// Loads the query.
/// </summary>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
/// <param name="query">The query.</param>
/// <param name="domainContext">The domain context.</param>
/// <param name="loadBehavior">The load behavior.</param>
/// <returns> Observable operation loading</returns>
public static IObservable <IEnumerable <TEntity> > ToObservable <TEntity>(this EntityQuery <TEntity> query, DomainContext domainContext, LoadBehavior loadBehavior = LoadBehavior.KeepCurrent)
where TEntity : Entity
{
return(Observable.Defer(
() =>
{
var asyncSubject = new AsyncSubject <IEnumerable <TEntity> >();
domainContext.Load(
query,
loadBehavior,
loadOperation =>
{
if (loadOperation.HasError)
{
asyncSubject.OnError(new OperationException(loadOperation.Error, loadOperation));
loadOperation.MarkErrorAsHandled();
}
else
{
asyncSubject.OnNext(loadOperation.Entities);
asyncSubject.OnCompleted();
}
},
null);
return asyncSubject;
}));
}
public override LoadOperation <TEntity> Load <TEntity>(EntityQuery <TEntity> query, LoadBehavior loadBehavior, Action <LoadOperation <TEntity> > callback, object userState)
{
this.LoadCalled = true;
return(base.Load(query, loadBehavior, callback, userState));
}
private static void _LoadScripts(IEnumerable <string> scriptPaths, LoadBehavior alredyLoaded = LoadBehavior.Reload)
{
SceneManager.AddSceneToStack(_loadingKey);
Task.Run(() =>
{
var loadingScreen = (LoadingScreenTemplate)SceneManager.GetScene(_loadingKey);
var tempDic = new Dictionary <string, ScriptingTemplate>();
foreach (var scriptPath in scriptPaths)
{
var scriptData = _scriptList[scriptPath];
if (scriptData.IsLoaded)
{
switch (alredyLoaded)
{
case LoadBehavior.Ignore:
continue;
case LoadBehavior.Reload:
break;
case LoadBehavior.ThrowException:
throw new Exception("Script already loaded \"" + scriptPath + "\"");
default:
throw new ArgumentOutOfRangeException(nameof(alredyLoaded), alredyLoaded, null);
}
}
loadingScreen.CurrentlyLoading(scriptPath);
var scriptCode = File.ReadAllText(scriptPath);
var script = CSharpScript.Create(scriptCode,
ScriptOptions
.Default.WithReferences(Assembly.GetCallingAssembly(),
Assembly
.GetExecutingAssembly(),
Assembly
.GetAssembly(typeof(Game
)),
_runningAssembly));
script.Compile();
var tempScriptType = script.RunAsync().Result.ReturnValue;
if (!(tempScriptType is Type))
{
throw new Exception("Return type of Script \"" + scriptPath + "\n is not correct");
}
var scriptType = (Type)tempScriptType;
tempDic[scriptPath] = (ScriptingTemplate)Activator.CreateInstance(scriptType);
}
foreach (var tempDicKey in tempDic.Keys)
{
var data = _scriptList[tempDicKey];
data.Template = tempDic[tempDicKey];
data.IsLoaded = true;
_scriptList[tempDicKey] = data;
}
loadingScreen.LoadingDone();
});
}
public override Task <LoadResult <TEntity> > LoadAsync <TEntity>(EntityQuery <TEntity> query, LoadBehavior loadBehavior,
CancellationToken cancellationToken = new CancellationToken())
{
LoadAsyncCalled = true;
return(base.LoadAsync(query, loadBehavior, cancellationToken));
}
public virtual LoadBehavior GetListCountLoadBehavior(LoadBehavior loadBehavior, IPropertyMap propertyMap)
{
if (loadBehavior == LoadBehavior.Default)
{
loadBehavior = propertyMap.ListCountLoadBehavior;
if (loadBehavior == LoadBehavior.Default)
{
loadBehavior = propertyMap.ClassMap.ListCountLoadBehavior;
if (loadBehavior == LoadBehavior.Default)
{
loadBehavior = propertyMap.ClassMap.DomainMap.ListCountLoadBehavior;
if (loadBehavior == LoadBehavior.Default)
{
loadBehavior = this.listCountLoadBehavior ;
if (loadBehavior == LoadBehavior.Default)
{
loadBehavior = LoadBehavior.Eager;
}
}
}
}
}
return loadBehavior;
}
/// <summary>
/// Method used to apply a value taking the specified LoadBehavior into account.
/// </summary>
/// <param name="o">The target object</param>
/// <param name="value">The value to apply</param>
/// <param name="member">The property to apply the value to</param>
/// <param name="originalState">The original state map for the object</param>
/// <param name="loadBehavior">The LoadBehavior to govern property merge behavior.</param>
private static void ApplyValue(object o, object value, MetaMember member, IDictionary <string, object> originalState, LoadBehavior loadBehavior)
{
if (loadBehavior == LoadBehavior.KeepCurrent)
{
return;
}
Lazy <object> lazyValue = value as Lazy <object>;
if (loadBehavior == LoadBehavior.RefreshCurrent)
{
// overwrite value with the new value
if (lazyValue != null)
{
value = lazyValue.Value;
}
member.SetValue(o, value);
}
else if (loadBehavior == LoadBehavior.MergeIntoCurrent)
{
if (!PropertyHasChanged(o, originalState, member))
{
// set the value only if our value hasn't been modified
if (lazyValue != null)
{
value = lazyValue.Value;
}
member.SetValue(o, value);
}
}
}
// Token: 0x060013FE RID: 5118 RVA: 0x0001E6FC File Offset: 0x0001D6FC
protected override WorkflowElement CreateBody()
{
StateGraph stateGraph = new StateGraph(string.Format("OpponentPursuit: {0}", base.Entrant.Opponent.OpponentName));
State state = new State("initial");
State state2 = new State("countdown");
State state3 = new State("inpursuit");
State state4 = new State("cooldown");
State state5 = new State("busted");
State state6 = new State("evaded");
State state7 = new State("post");
new State("aborted");
State state8 = new State("done");
GameCore.Activities.Entrant.Components.CloseOnReceive <OnPursuitEngaged> activity = new GameCore.Activities.Entrant.Components.CloseOnReceive <OnPursuitEngaged>(base.InstancedEvent, base.Entrant, Ports.Gameplay);
GameCore.Activities.Components.CloseOnReceive <OnPursuitBusted> activity2 = new GameCore.Activities.Components.CloseOnReceive <OnPursuitBusted>(Ports.Gameplay);
EntrantFinished activity3 = new EntrantFinished(base.InstancedEvent, base.Entrant, -8193);
EntrantFinished activity4 = new EntrantFinished(base.InstancedEvent, base.Entrant, 8202);
OnUpdateTick activity5 = new OnUpdateTick(base.InstancedEvent, base.Entrant);
Conclude item = new Conclude(base.InstancedEvent, base.Entrant);
FlushCops item2 = new FlushCops();
LoadBehavior item3 = new LoadBehavior(base.InstancedEvent, base.Entrant, "BEHAVIOR_GAMEPLAY_PURSUIT", "PursuitMonitorBehavior");
EntrantLoaded item4 = new EntrantLoaded(base.InstancedEvent, base.Entrant, "Entrants.Loading");
PrepareScoringMethod item5 = new PrepareScoringMethod(base.InstancedEvent, base.Entrant);
EnableLoadingScreen item6 = new EnableLoadingScreen(false);
HandleTutorial item7 = new HandleTutorial(base.InstancedEvent, base.Entrant, TutorialSource.kTutorialSource_Pursuit);
Launch item8 = new Launch(base.InstancedEvent, base.Entrant);
AssignPursuitEscalation item9 = new AssignPursuitEscalation(base.Event.EventDef.PursuitEscalation().GetKey());
state.EnterActivity.Activities.Add(item3);
state.Transitions.Add(new Transition("countdown"));
LockEntrant item10 = new LockEntrant(base.InstancedEvent, base.Entrant, true);
EnableKeyboard item11 = new EnableKeyboard(true);
FlushTraffic item12 = new FlushTraffic();
LoadBlackBoards item13 = new LoadBlackBoards(base.Event, BlackBoardFlag.kBlackBoardFlag_Running);
Countdown activity6 = new Countdown(base.InstancedEvent, base.Entrant);
TryPerfectLaunch item14 = new TryPerfectLaunch(base.InstancedEvent, base.Entrant);
LockEntrant item15 = new LockEntrant(base.InstancedEvent, base.Entrant, false);
LaunchPursuitByOpponentHeat item16 = new LaunchPursuitByOpponentHeat(base.InstancedEvent, base.Entrant);
state2.EnterActivity.Activities.Add(item10);
state2.EnterActivity.Activities.Add(item9);
state2.EnterActivity.Activities.Add(item5);
state2.EnterActivity.Activities.Add(item4);
state2.EnterActivity.Activities.Add(item11);
state2.EnterActivity.Activities.Add(item12);
state2.EnterActivity.Activities.Add(item6);
state2.EnterActivity.Activities.Add(item13);
state2.EnterActivity.Activities.Add(item7);
state2.Transitions.Add(new Transition("inpursuit", activity6));
state2.ExitActivity.Activities.Add(item14);
state2.ExitActivity.Activities.Add(item8);
state2.ExitActivity.Activities.Add(item15);
state2.ExitActivity.Activities.Add(item16);
VisualEffect item17 = new VisualEffect(EffectType.ENTER_COP_PURSUIT);
EnablePointsOfInterest item18 = new EnablePointsOfInterest(4291711951u, true);
GameCore.Activities.Entrant.Components.CloseOnReceive <OnPursuitCooldown> activity7 = new GameCore.Activities.Entrant.Components.CloseOnReceive <OnPursuitCooldown>(base.InstancedEvent, base.Entrant, Ports.Gameplay);
EnablePointsOfInterest item19 = new EnablePointsOfInterest(4291711951u, false);
state3.EnterActivity.Activities.Add(item17);
state3.EnterActivity.Activities.Add(item18);
state3.Transitions.Add(new Transition("cooldown", activity7));
state3.Transitions.Add(new Transition("busted", activity2));
state3.Transitions.Add(new Transition("done", activity4));
state3.Transitions.Add(new Transition(activity5));
state3.ExitActivity.Activities.Add(item19);
EnablePointsOfInterest item20 = new EnablePointsOfInterest(3470858927u, true);
GameCore.Activities.Entrant.Components.CloseOnReceive <OnPursuitEvaded> activity8 = new GameCore.Activities.Entrant.Components.CloseOnReceive <OnPursuitEvaded>(base.InstancedEvent, base.Entrant, Ports.Gameplay);
EnablePointsOfInterest item21 = new EnablePointsOfInterest(3470858927u, false);
HandleTutorial item22 = new HandleTutorial(base.InstancedEvent, base.Entrant, TutorialSource.kTutorialSource_PursuitCooldown);
state4.EnterActivity.Activities.Add(item20);
state4.EnterActivity.Activities.Add(item22);
state4.Transitions.Add(new Transition("inpursuit", activity));
state4.Transitions.Add(new Transition("evaded", activity8));
state4.Transitions.Add(new Transition("busted", activity2));
state4.Transitions.Add(new Transition("done", activity4));
state4.Transitions.Add(new Transition(activity5));
state4.ExitActivity.Activities.Add(item21);
FinishEntrant activity9 = new FinishEntrant(base.InstancedEvent, base.Entrant, FinishReason.Evaded);
HardwareBlinkingEffectEntrant item23 = new HardwareBlinkingEffectEntrant(base.InstancedEvent, base.Entrant, 4278216447u, 3.8f, 0.4f);
state6.EnterActivity.Activities.Add(item23);
state6.Transitions.Add(new Transition("post", activity3));
state6.Transitions.Add(new Transition("done", activity4));
state6.Transitions.Add(new Transition(activity9));
state6.ExitActivity.Activities.Add(item);
FinishEntrant activity10 = new FinishEntrant(base.InstancedEvent, base.Entrant, FinishReason.Busted);
HardwareBlinkingEffectEntrant item24 = new HardwareBlinkingEffectEntrant(base.InstancedEvent, base.Entrant, 4294901760u, 3f, 0.1f);
Bust item25 = new Bust(base.InstancedEvent, base.Entrant);
state5.EnterActivity.Activities.Add(item24);
state5.Transitions.Add(new Transition("post", activity3));
state5.Transitions.Add(new Transition("done", activity4));
state5.Transitions.Add(new Transition(activity10));
state5.ExitActivity.Activities.Add(item25);
OverrideVehicleControl item26 = new OverrideVehicleControl(base.Entrant.Opponent.Vehicle, OverrideVehicleControl.Control.Stop);
ReleaseBehavior item27 = new ReleaseBehavior(base.InstancedEvent, base.Entrant, "BEHAVIOR_GAMEPLAY_PURSUIT");
PostEventScreen activity11 = new PostEventScreen(base.InstancedEvent, base.Entrant, Ports.Gameplay);
ChangeBlackBoard item28 = new ChangeBlackBoard(BlackBoardChannel.kBlackBoard_Audio, 3114481865u);
ChangeBlackBoard item29 = new ChangeBlackBoard(BlackBoardChannel.kBlackBoard_AI, 331198907u);
state7.EnterActivity.Activities.Add(item28);
state7.EnterActivity.Activities.Add(item29);
state7.EnterActivity.Activities.Add(item26);
state7.EnterActivity.Activities.Add(item2);
state7.EnterActivity.Activities.Add(item12);
state7.EnterActivity.Activities.Add(item27);
state7.Transitions.Add(new Transition("done", activity11));
OverrideVehicleControl item30 = new OverrideVehicleControl(base.Entrant.Opponent.Vehicle, OverrideVehicleControl.Control.Release);
CleanupScoringMethod item31 = new CleanupScoringMethod(base.InstancedEvent, base.Entrant);
state8.EnterActivity.Activities.Add(item30);
state8.EnterActivity.Activities.Add(item31);
stateGraph.InitialState = "initial";
stateGraph.DoneState = "done";
stateGraph.States.Add(state);
stateGraph.States.Add(state2);
stateGraph.States.Add(state3);
stateGraph.States.Add(state4);
stateGraph.States.Add(state5);
stateGraph.States.Add(state6);
stateGraph.States.Add(state7);
stateGraph.States.Add(state8);
return(stateGraph);
}
public TableAttribute(string tableName, LoadBehavior loadBehavior)
{
TableName = tableName;
LoadBehavior = loadBehavior;
}
public static IEnumerable <T> Import <T>(this EntitySet <T> collection, IList <EntityStateSet> stateSet, LoadBehavior loadBehavior) where T : Entity, new()
{
List <T> loadedEntities = new List <T>();
Dictionary <object, T> identityCache = new Dictionary <object, T>();
foreach (T currentEntity in collection)
{
identityCache.Add(currentEntity.GetIdentity(), currentEntity);
}
foreach (EntityStateSet currentStateSet in stateSet)
{
T existingEntity;
identityCache.TryGetValue(currentStateSet.OriginalKey, out existingEntity);
if (existingEntity == null && currentStateSet.ModifiedKey != null)
{
identityCache.TryGetValue(currentStateSet.ModifiedKey, out existingEntity);
}
if (existingEntity == null)
{
T newEntity = new T();
if (currentStateSet.ModifiedState != null)
{
collection.Attach(newEntity);
}
newEntity.ApplyState(currentStateSet.OriginalState, currentStateSet.ModifiedState);
if (currentStateSet.ModifiedState == null)
{
collection.Attach(newEntity);
}
if (currentStateSet.IsDelete)
{
collection.Attach(newEntity);
collection.Remove(newEntity);
}
else
{
loadedEntities.Add(newEntity);
}
}
else if (loadBehavior == LoadBehavior.RefreshCurrent)
{
if (currentStateSet.IsDelete)
{
collection.Remove(existingEntity);
}
else
{
existingEntity.ApplyState(currentStateSet.OriginalState, currentStateSet.ModifiedState);
loadedEntities.Add(existingEntity);
}
}
}
return(new ReadOnlyCollection <T>(loadedEntities));
}