/// <summary> /// Initializes the RuntimeTemplate with data from the given ContentTemplate. /// </summary> public void Initialize(ContentTemplateSerializationFormat template) { TemplateId = template.TemplateId; PrettyName = template.PrettyName; foreach (Data.IData data in template.DefaultDataInstances) { _defaultDataInstances[DataAccessorFactory.GetId(data)] = data; } }
public void Initialize(ContentEntitySerializationFormat format) { PrettyName = format.PrettyName ?? ""; UniqueId = format.UniqueId; foreach (DataInstance data in format.Data) { _data[DataAccessorFactory.GetId(data.CurrentData)] = data; } }
/// <summary> /// Attempts to retrieve a data instance with the given DataAccessor from the list of added /// data. /// </summary> /// <param name="accessor">The DataAccessor to lookup</param> /// <returns>A data instance, or null if it cannot be found</returns> private Data.IData GetAddedData_unlocked(DataAccessor accessor) { int id = accessor.Id; // TODO: optimize this so we don't have to search through all added data... though // this should actually be pretty quick for (int i = 0; i < _toAddStage1.Count; ++i) { int addedId = DataAccessorFactory.GetId(_toAddStage1[i].GetType()); if (addedId == id) { return(_toAddStage1[i]); } } return(null); }
/// <summary> /// Creates a new DataAccessor that accesses the specified Data type. /// </summary> /// <param name="dataType">The type of Data to retrieve; note that this parameter must be a /// subtype of Data</param> public DataAccessor(Type dataType) : this() { Id = DataAccessorFactory.GetId(dataType); }
/// <summary> /// Applies data state changes to the entity. /// </summary> /// <remarks> /// This function is not thread-safe; no other API calls can be made to the Entity while /// this function is being executed. /// </remarks> /// <returns>If more data state change updates are needed</returns> public void DataStateChangeUpdate() { // do removals { for (int i = 0; i < _toRemoveStage1.Count; ++i) { int id = _toRemoveStage1[i].Id; _removedLastFrame[id] = _toRemoveStage1[i]; // _removedLastFrame[id] is removed in stage2 _eventDispatcher.Submit(RemovedDataEvent.Create(this, DataAccessorFactory.GetTypeFromId(id))); } for (int i = 0; i < _toRemoveStage2.Count; ++i) { int id = _toRemoveStage2[i].Id; _removedLastFrame.Remove(id); _data.Remove(id); } _toRemoveStage2.Clear(); Utils.Swap(ref _toRemoveStage1, ref _toRemoveStage2); } // We don't throw an exception immediately. If we are throwing an exception, that means // that the Entity is in an invalid state (adding a bad data instance). However, the // only way to recover from that invalid state is by having this method terminate. // Hence, we only throw an exception at the end of the method. Exception exceptionToThrow = null; // do additions for (int i = 0; i < _toAddStage1.Count; ++i) { Data.IData added = _toAddStage1[i]; int id = DataAccessorFactory.GetId(added.GetType()); // make sure we do not readd the same data instance twice if (_data.ContainsKey(id)) { exceptionToThrow = new AlreadyAddedDataException(this, new DataAccessor(added)); continue; } _addedLastFrame[id] = added; if (added is Data.IVersioned) { Data.IVersioned versioned = (Data.IVersioned)added; _data[id] = new VersionedDataContainer(versioned.Duplicate(), versioned.Duplicate(), versioned.Duplicate()); } else { Data.NonVersioned nonVersioned = (Data.NonVersioned)added; _data[id] = new NonVersionedDataContainer(nonVersioned); } // visualize the initial data _eventDispatcher.Submit(AddedDataEvent.Create(this, added.GetType())); } for (int i = 0; i < _toAddStage2.Count; ++i) { _addedLastFrame.Remove(new DataAccessor(_toAddStage2[i]).Id); } _toAddStage2.Clear(); Utils.Swap(ref _toAddStage1, ref _toAddStage2); if (exceptionToThrow != null) { throw exceptionToThrow; } }
/// <summary> /// Adds a default data instance to the template. The template "owns" the passed data /// instance; a copy is not made of it. /// </summary> /// <remarks> /// If the ITemplate is currently being backed by an IGameEngine, this will throw an /// InvalidOperationException. /// </remarks> /// <param name="data">The data instance to copy from.</param> public void AddDefaultData(Data.IData data) { _defaultDataInstances[DataAccessorFactory.GetId(data)] = data; }