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();
}
