protected void Awake()
{
if (_myPool == null && !ObjectPoolController._isDuringInstantiate)
{
CustomDebug.LogWarning("Poolable object " + name + " was instantiated without ObjectPoolController");
}
}
void InitHandlerObjects()
{
foreach (var obj in layoutHandlerObjects)
{
if (obj != null)
{
ILayoutCellHandler handler = obj.GetComponent <ILayoutCellHandler>();
if (handler != null)
{
if (!layoutHandlers.Contains(handler))
{
layoutHandlers.Add(handler);
}
}
else
{
gameObject.name = CachedName + "(NOT_FOUND_HANDLERS)";
CustomDebug.LogWarning("no handlers found in GUILayoutCell references, gameObject name = " + CachedName, this);
}
}
else
{
gameObject.name = CachedName + "(NOT_FOUND_HANDLERS)";
CustomDebug.LogWarning("no handlers found in GUILayoutCell references, gameObject name = " + CachedName, this);
}
}
}
/// <summary>
/// Preloads as many instances to the pool so that there are at least as many as
/// specified in <see cref="PoolableObject.preloadCount"/>.
/// </summary>
/// <param name="prefab">The prefab.</param>
/// <remarks>
/// Use ObjectPoolController.isDuringPreload to check if an object is preloaded in the <c>Awake()</c> function.
/// If the pool already contains at least <see cref="PoolableObject.preloadCount"/> objects, the function does nothing.
/// </remarks>
/// <seealso cref="PoolableObject.preloadCount"/>
static public void Preload(GameObject prefab) // adds as many instances to the prefab pool as specified in the PoolableObject
{
PoolableObject poolObj = prefab.GetComponent <PoolableObject>();
if (poolObj == null)
{
CustomDebug.LogWarning("Can not preload because prefab '" + prefab.name + "' is not poolable");
return;
}
var pool = _GetPool(poolObj); // _preloadDone is set by _GetPool
int delta = poolObj.preloadCount - pool.GetObjectCount();
if (delta <= 0)
{
return;
}
isDuringPreload = true;
try
{
for (int i = 0; i < delta; i++)
{
pool.PreloadInstance();
}
}
finally
{
isDuringPreload = false;
}
//Debug.Log( "preloaded: " + prefab.name + " " + poolObj.preloadCount + " times" );
}
public override void Parse(IPEndPoint client, byte[] data)
{
MemoryStream memoryStream = new MemoryStream(data);
try{
object obj = formatter.Deserialize(memoryStream);
if (obj is ServerData)
{
ServerData parsedData = (ServerData)obj;
CustomDebug.Log("Object received : " + parsedData.GetType(), VerboseLevel.ALL);
parsedData.ValidateAndExecute(clientInformations, client);
}
else
{
throw new BadDataException("Not a valid Data " + obj.GetType());
}
} catch (BadDataException e) {
CustomDebug.LogWarning("Bad Message ! " + e.Message, VerboseLevel.INFORMATIONS);
} catch (Exception e) {
throw e;
}
memoryStream.Close();
}
public void SendData(ClientData message)
{
try{
base.SendData(serverEndPoint, message);
} catch (ObjectDisposedException) {
CustomDebug.LogWarning("Object disposed, Close Client", VerboseLevel.IMPORTANT);
Close();
}
}
public new void SendData(IPEndPoint client, Data message)
{
try{
base.SendData(client, message);
} catch (ObjectDisposedException) {
CustomDebug.LogWarning("Object disposed, Client removed", VerboseLevel.IMPORTANT);
RemoveClient(client);
}
}
static public T GetSingleton(bool autoCreate)
{
if (!instanceT) // Unity operator to check if object was destroyed,
{
T component = null;
#if UNITY_EDITOR
if ((Application.isPlaying) && (!UnityEditor.EditorApplication.isPaused))
{
var components = GameObject.FindObjectsOfType <T>();
foreach (var c in components)
{
var singletonCpt = (ISingletonMonoBehaviour)(c);
if (singletonCpt.IsSingletonObject)
{
component = c;
CustomDebug.LogError("Must call base.Awake() singleton : " + typeT.Name);
break;
}
}
}
#endif
if (!component)
{
if (autoCreate
#if UNITY_EDITOR
&& Application.isPlaying &&
!UnityEditor.EditorApplication.isPaused
#endif
&& !destroySingletonCalled
)
{
GameObject go = new GameObject(typeT.Name, new Type[] { typeT });
go.transform.parent = AutocreateRoot;
CustomDebug.LogWarning("Create singleton : " + typeT.Name);
component = go.GetComponent <T>();
if (component == null)
{
CustomDebug.LogError("Auto created object does not have component " + typeT.Name);
component = null;
}
}
else
{
component = null;
}
}
instanceT = component;
}
return(instanceT);
}
public void RemoveClient(IPEndPoint client)
{
ClientToken token;
if (clients.TryRemove(client, out token))
{
removedClients.Add(token.id);
CustomDebug.LogWarning("Remove Client " + client.Address.ToString() + ":" + client.Port.ToString(), VerboseLevel.IMPORTANT);
}
}
// redundant code with RegisteredComponentEx !!
protected virtual void Awake()
{
if (!isRegistered)
{
RegisteredComponentController._Register(this);
isRegistered = true;
isUnregistered = false;
}
else
{
CustomDebug.LogWarning("RegisteredComponent: Awake() / OnDestroy() not correctly called. Object: " + name);
}
}
public void SendCallback(IAsyncResult asyncResult)
{
try{
if (socket.EndSend(asyncResult) == 0)
{
CustomDebug.LogWarning("Send empty message", VerboseLevel.IMPORTANT);
}
}
catch (Exception e)
{
Close();
Debug.LogException(e);
}
}
void InitHandlerObjects()
{
foreach (var obj in layoutHandlerObjects)
{
ILayoutCellHandler handler = obj.GetComponent(typeof(ILayoutCellHandler)) as ILayoutCellHandler;
if (handler != null)
{
layoutHandlers.Add(handler);
}
else
{
gameObject.name = "NOT_FOUND_HANDLERS";
CustomDebug.LogWarning("no handlers found in GUILayoutCell references, gameObject name = " + name);
}
}
}
static internal void InternalAwake(T instance)
{
globalInstanceCount++;
if (globalInstanceCount > 1)
{
#if UNITY_EDITOR
if ((Application.isPlaying) && (!UnityEditor.EditorApplication.isPaused))
#endif
{
// can happen if an exception occurred that prevented correct instance counting
CustomDebug.LogWarning("More than one awake of SingletonMonoBehaviour " + typeof(T).Name);
}
}
else
{
instanceT = (T)instance;
}
}
protected virtual void OnDestroy()
{
if (isRegistered && !isUnregistered)
{
RegisteredComponentController._Unregister(this);
isRegistered = false;
isUnregistered = true;
}
else
{
bool alreadyUnregisteredProperly = !isRegistered && isUnregistered;
if (!alreadyUnregisteredProperly) // for poolable objects OnDestroy() can get called multiple times
{
CustomDebug.LogWarning("RegisteredComponent: Awake() / OnDestroy() not correctly called. Object: " + name + " isRegistered:" + isRegistered + " isUnregistered:" + isUnregistered);
}
}
}
public XElement ParseValueForSave(object node)
{
if ((node is string) || (node == null))
{
return(new XElement(TYPE_STRING, node as string));
}
else if (node is int || node is long)
{
return(new XElement(TYPE_INTEGER, ((int)node).ToString(System.Globalization.NumberFormatInfo.InvariantInfo)));
}
else if (node is PBXPlistDict)
{
return(ParseDictForSave((PBXPlistDict)node));
}
else if (node is ArrayList)
{
return(ParseArrayForSave(node));
}
else if (node is byte[])
{
return(new XElement(TYPE_DATA, Convert.ToBase64String((Byte[])node)));
}
else if (node is float || node is double)
{
return(new XElement(TYPE_REAL, ((double)node).ToString(System.Globalization.NumberFormatInfo.InvariantInfo)));
}
else if (node is DateTime)
{
DateTime time = (DateTime)node;
string stringTime = XmlConvert.ToString(time, XmlDateTimeSerializationMode.Utc);
return(new XElement(TYPE_DATE, stringTime));
}
else if (node is bool)
{
return(new XElement(node.ToString().ToLower()));
}
else
{
CustomDebug.LogWarning("PBXPlistDict: Format unsupported, Parser update needed");
}
return(null);
}
static public void DeleteArrayElement <T>(ref T[] array, int index)
{
if (index >= array.Length || index < 0)
{
CustomDebug.LogWarning("invalid index in DeleteArrayElement: " + index);
return;
}
var newArray = new T[array.Length - 1];
int i;
for (i = 0; i < index; i++)
{
newArray[i] = array[i];
}
for (i = index + 1; i < array.Length; i++)
{
newArray[i - 1] = array[i];
}
array = newArray;
}
private object ParseValueForLoad(XElement val)
{
switch (val.Name.ToString())
{
case TYPE_STRING:
return(val.Value);
case TYPE_INTEGER:
return(int.Parse(val.Value));
case TYPE_REAL:
return(float.Parse(val.Value));
case TYPE_TRUE:
return(true);
case TYPE_FALSE:
return(false);
case TYPE_DICT:
PBXPlistDict plist = new PBXPlistDict();
ParseDictForLoad(plist, val.Elements());
return(plist);
case TYPE_ARRAY:
return(ParseArrayForLoad(val.Elements()));
case TYPE_NULL:
return(null);
case TYPE_DATE:
return(XmlConvert.ToDateTime(val.Value, XmlDateTimeSerializationMode.Utc));
case TYPE_DATA:
return(Convert.FromBase64String(val.Value));
default:
CustomDebug.LogWarning("PBXPlistDict: Format unsupported, Parser update needed");
return(null);
}
}
static internal void InternalDestroy()
{
if (globalInstanceCount > 0)
{
globalInstanceCount--;
if (globalInstanceCount == 0)
{
destroySingletonCalled = true;
instanceT = null;
}
}
else
{
#if UNITY_EDITOR
if ((Application.isPlaying) && (!UnityEditor.EditorApplication.isPaused))
#endif
{
// can happen if an exception occurred that prevented correct instance counting
CustomDebug.LogWarning("More than one destroy of SingletonMonoBehaviour " + typeof(T).Name);
}
}
}
/// <summary>
/// Destroys the specified game object, respectively sets the object inactive and adds it to the pool.
/// </summary>
/// <param name="obj">The game object.</param>
/// <remarks>
/// Can be used on none-poolable objects as well. It is good practice to use <c>ObjectPoolController.Destroy</c>
/// whenever you may possibly make your prefab poolable in the future. <para/>
/// Must also be used on none-poolable objects with poolable child objects so the poolable child objects are correctly
/// moved to the pool.
/// </remarks>
/// <seealso cref="Instantiate(GameObject)"/>
static public void Destroy(GameObject obj) // destroys poolable and none-poolable objects. Destroys poolable children correctly
{
PoolableObject poolObj = obj.GetComponent <PoolableObject>();
if (poolObj == null)
{
_DetachChildrenAndDestroy(obj.transform); // child objects may be poolable
GameObject.Destroy(obj); // prefab not pooled, destroy normally
return;
}
if (poolObj._myPool != null)
{
poolObj._myPool._SetAvailable(poolObj, true);
}
else
{
if (!poolObj._createdWithPoolController)
{
CustomDebug.LogWarning("Poolable object " + obj.name + " not created with ObjectPoolController");
}
GameObject.Destroy(obj); // prefab not pooled, destroy normally
}
}
void InitReference(bool force)
{
if (force || ((tk2dSprite == null) && (tk2dLabel == null) && (quad == null) && (drawableMesh == null)))
{
tk2dSprite = Target.GetComponent <tk2dBaseSprite>();
tk2dLabel = Target.GetComponent <tk2dTextMesh>();
quad = Target.GetComponent <ColorQuad>();
drawableMesh = Target.GetComponent <DrawableMesh>();
objectColor = Target.GetComponent <ITweenColor>();
if ((tk2dSprite == null) &&
(tk2dLabel == null) &&
(quad == null) &&
(drawableMesh == null) &&
(objectColor == null))
{
meshRenderer = Target.GetComponent <MeshRenderer>();
if (meshRenderer != null && (meshRenderer.sharedMaterial == null || !meshRenderer.sharedMaterial.HasProperty("_Color")))
{
CustomDebug.LogWarning("Wrong material!");
meshRenderer = null;
}
}
}
}
public override void Close()
{
base.Close();
CustomDebug.LogWarning("Connexion Closed", VerboseLevel.IMPORTANT);
}
public virtual void BadReceive()
{
CustomDebug.LogWarning("Bad reception", VerboseLevel.INFORMATIONS);
socket.BeginReceive(new AsyncCallback(ReceiveCallback), null);
}
