public void OnPhotonPlayerDisconnected(PhotonPlayer otherPlayer) { while (ManagedObjects.GetOwnersObjects(otherPlayer.ID).Count > 0) { ObjectPoolManager.Delete(ManagedObjects.GetOwnersObjects(otherPlayer.ID)[0]); } }
public virtual void ActivateObjects() { List <T> toBeRemoved = new List <T>(); //TODO: Trace usage paths to confirm transaction is needed using (Transaction acTrans = HostDocument.Database.TransactionManager.StartTransaction()) { foreach (T managedObject in ManagedObjects) { if (!managedObject.CreateActiveObject()) { toBeRemoved.Add(managedObject); } } acTrans.Commit(); } foreach (T removeObj in toBeRemoved) { ManagedObjects.Remove(removeObj); } SetActiveObjects(); }
public void AddTree(Tree tree) { ManagedObjects.Add(tree); tree.DirtyAdded = true; //TODO: Move into base //DrawingObjectManagerCollection.Current.FlagDirty(); }
internal void UnregisterObject(Object obj) { lock (ManagedObjects) { if (!ManagedObjects.Contains(obj)) { return; } ManagedObjects.Remove(obj); if (obj is GameObject gameObject) { if ((gameObject.Id.Flags & ObjectIdFlags.Spawned) != 0) { SpawnedObjects.Remove(gameObject); } } var updated = UpdatedObjects.FirstOrDefault(u => u.Associate == obj); if (updated == default) { return; } UpdatedObjects.Remove(updated); } }
/// <summary> /// Clears the <see cref="ChannelsManager"/>, disassociating any <see cref="Channel"/>s /// </summary> protected override void Clear() { foreach (Channel ch in ManagedObjects.ContentsAs_ListCopy) { ManagedObjects.Remove(ch); } base.Clear(); }
/// <summary> /// Clears the <see cref="MediaDataManager"/> disassociating any linked <see cref="MediaData"/> /// </summary> protected override void Clear() { foreach (MediaData md in ManagedObjects.ContentsAs_ListCopy) { ManagedObjects.Remove(md); } base.Clear(); }
/// <summary> /// Clears the <see cref="ExternalFileDataDataManager"/> disassociating any linked <see cref="ExternalFileData"/> /// </summary> protected override void Clear() { foreach (ExternalFileData EFd in ManagedObjects.ContentsAs_ListCopy) { ManagedObjects.Remove(EFd); } base.Clear(); }
public override BasicLocus Create() { BasicLocus locus = Init(GetRandomLocusType()); ManagedObjects.Add(locus); locus.OnCreated(); return(locus); }
public void Clear() { foreach (T managedObject in ManagedObjects) { managedObject.Erase(); } ManagedObjects.Clear(); SetActiveObjects(); }
private static void CleanUpObjects() { List <GameObject> items = ManagedObjects.GetAllObjects(); while (items.Count > 0) { Delete(items[0]); items.Remove(items[0]); } }
///// <summary> ///// Remove all <see cref="DataProvider"/> that are managed by the manager ///// </summary> ///// <param name="delete">A <see cref="bool"/> indicating if the removed data providers should be deleted</param> //public void RemoveUnusedDataProviders(List<DataProvider> usedDataProviders, bool delete) //{ // foreach (DataProvider prov in ManagedObjects.ContentsAs_YieldEnumerable) // { // if (!usedDataProviders.Contains(prov)) // { // RemoveDataProvider(prov, delete); // } // } //} #endregion #region IXukAble Members /// <summary> /// Clears the <see cref="DataProviderManager"/>, clearing any links to <see cref="DataProvider"/>s /// </summary> protected override void Clear() { foreach (DataProvider dp in ManagedObjects.ContentsAs_ListCopy) { ManagedObjects.Remove(dp); } mDataFileDirectory = null; mXukedInFilDataProviderPaths.Clear(); base.Clear(); }
public static GameObject PhotonRpcInstantiateAsChild(string prefabPath, Vector3 position, Quaternion rotation, object[] data, int parentTokenId) { InstantiationData i = InstantiationData(prefabPath, position, rotation, data); i.PoolType = PoolType.RPC; var g = ObjectPoolManager.Instantiate(i); g.transform.parent = ManagedObjects.Find(parentTokenId).transform; ObjectPoolRpcManager.InstantiateAsChild(i, parentTokenId); return(g); }
public void BuildNewRoute(double initialInvert, double gradient, List <DrainageVertex> vertices) { using (var acTrans = TransactionFactory.CreateFromNew()) { var route = new DrainageRoute(initialInvert, gradient, vertices); route.CreateActiveObject(); ManagedObjects.Add(route); acTrans.Commit(); } UpdateAll(); }
/// <summary> /// Add new object to managed object collection /// </summary> /// <param name="toBeManaged">Object to be added. Dirty added does not need to be marked</param> public void Add(T toBeManaged) { if (!toBeManaged.Active) { throw new ArgumentException("Drawing object not active."); } ManagedObjects.Add(toBeManaged); toBeManaged.DirtyAdded = true; //TODO: Belt and Braces. Review implementation of Active and Managed object lists in line with dirty system. SetActiveObjects(); }
/// <summary> /// Method to iterate over managed objects and remove any that have been deleted /// </summary> public void RemoveErased() { //TODO: Review how to handle erased base objects List <int> indicesToRemove = new List <int>(); for (int i = ManagedObjects.Count - 1; i >= 0; i--) { if (ManagedObjects[i].DirtyRemoved) { indicesToRemove.Add(i); } } indicesToRemove.Reverse(); foreach (int i in indicesToRemove) { ManagedObjects.RemoveAt(i); } }
private static bool TryGetId(out int Id) { bool foundVal = false; int returnId = PhotonNetwork.player.ID * MAX_ITEMS + itemsCreated % (MAX_ITEMS); if (ManagedObjects.Find(returnId) == null) { Id = returnId; foundVal = true; } else { Id = -1; foundVal = false; } if (++itemsCreated >= MAX_ITEMS) { itemsCreated = 0; } return(foundVal); }
public int DefaultMaxPoolSize = 100; //Objects added to a pool beyond its max size will be permanently deleted void Awake() { if (PersistThroughLoad) { DontDestroyOnLoad(this); } ObjectPoolRpcManager.Initialize(); ObjectPoolManager.Initialize(); ManagedObjects.Initialize(); itemsCreated = 0; LocalPools = new Dictionary <string, Pool>(); PhotonViewPools = new Dictionary <string, Pool>(); RPCPools = new Dictionary <string, Pool>(); objectPool = this; PreloadedPool[] poolsArray = GetComponentsInChildren <PreloadedPool>(); if (LogFull) { Debug.Log("Found " + poolsArray.Length + " pools to preload."); } List <PreloadedPool> pools = new List <PreloadedPool>(poolsArray); while (pools.Count > 0) { PreloadedPool p = pools[0]; Pool pool = Pool.InitializePool(this, p.PrefabString, p.PoolType, p.MaxPoolSize, p.PreloadSize, p.gameObject); PoolFromPoolType(p.PoolType)[p.PrefabString] = pool; pool.RenameGameObject(); pools.Remove(p); Destroy(p); } }
internal void RegisterObject(Object obj) { lock (ManagedObjects) { if (ManagedObjects.Contains(obj)) { return; } OnObject.Invoke(obj); ManagedObjects.Add(obj); if (!(obj is GameObject gameObject)) { return; } if ((gameObject.Id.Flags & ObjectIdFlags.Spawned) != 0) { SpawnedObjects.Add(gameObject); } } }
public static GameObject Find(int tokenId) { return(ManagedObjects.Find(tokenId)); }
/// <summary> /// Unregister the <see cref="IManagedObject"/>. The object is then no longer managed by the <see cref="HoloFlowSceneManager"/> /// </summary> /// <param name="mObject"></param> public void UnregisterObject(IManagedObject mObject) { ManagedObjects.Remove(mObject); }
/// <summary> /// Registers a <see cref="IManagedObject"/> which should be managed by the <see cref="HoloFlowSceneManager"/> /// </summary> public void RegisterObject(IManagedObject mObject) { ManagedObjects.Add(mObject); }
public static GameObject GetMyPlayerController() { return(ManagedObjects.GetPlayerController(PhotonNetwork.player.ID)); }
public static List <GameObject> GetMyObjectsOfType(string prefabPath) { return(ManagedObjects.GetOwnersObjectsOfType(PhotonNetwork.player.ID, prefabPath)); }
private void SetActiveObjects() { _activeObjects = ManagedObjects.Where(obj => !obj.Erased).ToList().AsReadOnly(); }
public override void Destroy(BasicLocus locus) { ManagedObjects.Remove(locus); locus.OnDestroyed(); }
void OnDestroy() { ObjectPoolRpcManager.Uninitialize(); ObjectPoolManager.Uninitialize(); ManagedObjects.Uninitialize(); }