private void ReadActivities(Activities processTypeActivities, PoolElement poolElement) { if (processTypeActivities != null && processTypeActivities.Activity != null) { foreach (Activity activity in processTypeActivities.Activity) { object activityItem = activity.Item; if (activityItem != null) { IActivityMapper mapper = ActivityMapperAttribute.GetMapper(activityItem.GetType()); if (mapper != null) { IBaseElement element = mapper.CreateElement(activityItem, activity.NodeGraphicsInfos); element.Name = activity.Name; element.Guid = Guid.Parse(activity.Id); _elements.Add(element.Guid, element); poolElement.Elements.Add(element); } else { throw new MapperNotFoundException(activityItem.GetType()); } } } } }
public void CreatePool(GameObject poolAbleObject, int poolSize = 50) { #region Protectors IPoolable objInterface = poolAbleObject.GetComponent <IPoolable>(); if (objInterface == null) { Debug.LogWarningFormat("Can't create objectPool to object: {0}. There is no 'IPoolable' interface", poolAbleObject.name); return; } if (poolSize < 0) { poolSize = 20; } #endregion if (pools.Find(x => x.Key.Equals(poolAbleObject.name)) == null) { GameObject tempParrent = Instantiate(poolContainer, gameObject.transform); tempParrent.name = string.Format("{0}_Pool", poolAbleObject.name); PoolElement tmpPoolScript = tempParrent.GetComponent <PoolElement>(); if (tmpPoolScript != null) { tmpPoolScript.CreatePool(poolAbleObject.gameObject, poolSize, tempParrent.transform); pools.Add(tmpPoolScript); } } }
///////////////////////////////////////////// public ObjectPool(int numElements, GameObject go) { if (numElements < 1) { Debug.LogError("Failed to init the Object Pool"); return; } #if DEBUG mMinimumAvailableElements = numElements; #endif mActiveObjects = new List <PoolElement>(); mAvailableObjects = new Queue <PoolElement>(); GameObject root = new GameObject("Pool_" + go.name); for (int i = 0; i < numElements; i++) { GameObject newOb = Object.Instantiate(go); newOb.transform.parent = root.transform; PoolElement component = newOb.GetComponent <PoolElement>(); if (component == null) { Debug.LogError("ObjectPool: the GameObject " + go + " doesn't have a PoolElement component."); } component.SetProprietaryPool(this); component.Deactivate(); mAvailableObjects.Enqueue(component); } }
private Transitions GetTransitions(PoolElement poolElement) { Transitions transitions = new Transitions(); transitions.Transition = new Transition[poolElement.Connections.Count]; HashSet <Guid> guids = new HashSet <Guid>(poolElement.Elements.Select(item => item.Guid)); for (int i = 0; i < poolElement.Connections.Count; i++) { ConnectionElement connectionElement = poolElement.Connections[i]; bool containsFirst = guids.Contains(connectionElement.SourceElement.Guid); if (!containsFirst) { _errorList.Add(string.Format("Cannot create transition. Pool does not contains source element: {0}", connectionElement.SourceElement.Guid)); } bool containsSecond = guids.Contains(connectionElement.TargetElement.Guid); if (!containsSecond) { _errorList.Add(string.Format("Cannot create transition. Pool does not contains target element: {0}", connectionElement.TargetElement.Guid)); } if (containsSecond && containsFirst) { Transition transition = new Transition(); transition.Id = connectionElement.GetId(); transition.From = connectionElement.SourceElement.GetId(); transition.To = connectionElement.TargetElement.GetId(); transitions.Transition[i] = transition; transition.ConnectorGraphicsInfos = CreateConnectorGraphicsInfos(connectionElement); } } return(transitions); }
private void ReadTransitions(ProcessType processType) { if (processType.Transitions?.Transition == null) { return; } foreach (var transition in processType.Transitions.Transition) { var from = transition.From; var to = transition.To; PoolElement poolElement = null; var guid = Guid.Parse(processType.Id); if (_poolByProcessDictionary.TryGetValue(guid, out poolElement)) { try { IBaseElement fromElement = _elements[Guid.Parse(from)]; IBaseElement toElement = _elements[Guid.Parse(to)]; ConnectionElement connection = new ConnectionElement(fromElement, toElement); connection.Guid = Guid.Parse(transition.Id); List <Point> points = GetPoints(transition.ConnectorGraphicsInfos); connection.Points = points; poolElement.Connections.Add(connection); } catch (KeyNotFoundException ex) { throw new BaseElementNotFoundException(ex); } } } }
private void ReadPools(Pools packagePools) { foreach (Pool pool in packagePools.Pool) { Guid guid = Guid.Parse(pool.Id); Guid processGuid = Guid.Parse(pool.Process); PoolElement poolElement = new PoolElement(guid) { Name = pool.Name, Guid = guid, ProcessGuid = processGuid }; _poolByProcessDictionary.Add(processGuid, poolElement); if (poolElement.Name != XpdlInfo.MainPoolName) { SetVisualElementInfo(pool.NodeGraphicsInfos, poolElement); Document.Pools.Add(poolElement); } else { Document.MainPoolElement = poolElement; } SetLanes(poolElement, pool); } }
private void AddNewPoolElement() { GameObject go = GameObject.Instantiate(_prefab); PoolElement poolElement = go.AddComponent <PoolElement>(); poolElement.Pool = this; _pool.Push(go); }
private void OnTriggerEnter(Collider other) { PoolElement e = other.GetComponent <PoolElement>(); if (e.Spawner != this && other.tag.CompareTo(this.tag) == 0) { e.release(); } }
public void PopBlossom(Vector2 position) { StartCoroutine(m_scriptSoundManager.Pop()); PoolElement leaf = m_blossomleafPool.Pop(); leaf.gameObject.transform.position = position; leaf.GetComponent <BlossomLeaf>().Fall(); m_nPopCount++; }
private void ReadHeader(ProcessHeader processHeader, PoolElement poolElement) { if (processHeader?.Created != null) { DateTime dateTime; if (DateTime.TryParse(processHeader.Created.Value, out dateTime)) { poolElement.CreatedOn = dateTime; } } }
//Set an object to disabled ///////////////////////////////////////////// public void Destroy(PoolElement element) { if (!mActiveObjects.Contains(element)) { Debug.LogWarning("ObjectPool: object is not active " + element + "."); return; } Debug.Log("ObjectPool: deactivating object " + element.gameObject); element.Deactivate(); mActiveObjects.Remove(element); mAvailableObjects.Enqueue(element); }
public void ReturtToPool(GameObject prefab) { PoolElement foundedPool = pools.Find(x => prefab.name.StartsWith(x.Key)); if (foundedPool != null) { prefab.transform.SetParent(foundedPool.parrent); } else { Debug.LogError("Can't fond ObjectPool for this object: " + prefab.name); } }
public GameObject GetGameObjectFromPool(string nameOfPrefab, System.Action <GameObject> beforeActive = null) { PoolElement foundedPool = pools.Find(x => x.Key == nameOfPrefab); if (foundedPool != null) { return(foundedPool.GetFromPool(beforeActive)); } else { Debug.LogError("Can't fond ObjectPool for this object: " + nameOfPrefab); } return(null); }
private void ReadProcesses(WorkflowProcesses workflowProcesses) { foreach (ProcessType processType in workflowProcesses.WorkflowProcess) { Guid processGuid = Guid.Parse(processType.Id); PoolElement poolElement = null; if (_poolByProcessDictionary.TryGetValue(processGuid, out poolElement)) { ReadHeader(processType.ProcessHeader, poolElement); ReadActivities(processType.Activities, poolElement); } ReadTransitions(processType); } }
public GameObject GetGameObjectFromPool(GameObject prefab, System.Action <GameObject> beforeActive = null) { PoolElement foundedPool = pools.Find(x => x.reference == prefab); if (foundedPool != null) { return(foundedPool.GetFromPool(beforeActive)); } else { Debug.LogError("Can't fond ObjectPool for this object: " + prefab.name); } return(null); }
/// <summary> /// Creates xpdl pool based on program pool /// </summary> /// <param name="poolElement"></param> /// <param name="isVisible"></param> /// <returns></returns> private static Pool CreatePool(PoolElement poolElement, bool isVisible = true) { Pool result = new Pool(); result.BoundaryVisible = isVisible; result.Id = poolElement.GetId(); result.Process = poolElement.ProcessGuid.ToString(); result.Lanes = GetLanes(poolElement); result.Name = poolElement.Name; result.NodeGraphicsInfos = new NodeGraphicsInfos(); result.NodeGraphicsInfos.NodeGraphicsInfo = new NodeGraphicsInfo[1]; result.NodeGraphicsInfos.NodeGraphicsInfo[0] = CreateNodeGraphicsInfo(poolElement); return(result); }
private ProcessType GetProcess(PoolElement poolElement) { ProcessType processType = new ProcessType(); processType.Id = poolElement.ProcessGuid.ToString(); processType.ProcessHeader = new ProcessHeader(); processType.ProcessHeader.Created = new Created() { Value = XpdlInfo.GetUtcDateTime(poolElement.CreatedOn) }; processType.Name = poolElement.Name; processType.Activities = GetActivities(poolElement.Elements); processType.Transitions = GetTransitions(poolElement); return(processType); }
public void Resize(int size) { int oldSize = _pooledList.Length; int newSize = size; PoolElement[] newArr = new PoolElement[size]; try { System.Array.Copy(_pooledList, newArr, _pooledList.Length); } catch (System.ArgumentException e) { Debug.Log(e.Message); for (int i = 0; i < _pooledList.Length; ++i) { newArr[i] = _pooledList[i]; } } _pooledAmount = newSize; _pooledList = newArr; for (int i = oldSize; i < size; i++) { GameObject o = GameObject.Instantiate(_prefabsObject) as GameObject; o.transform.parent = _parent; if (_parent == null) { if (_poolingContainer == null) { _poolingContainer = GameObject.FindWithTag("PoolingContainer"); } if (_poolingContainer != null) { o.transform.parent = _poolingContainer.transform; } } _pooledList[i] = new PoolElement(); _pooledList[i]._element = o; _pooledList[i]._reserved = false; } Debug.Log("Resize pool manager " + _tag + " from " + oldSize.ToString() + " to " + newSize.ToString()); _loaded = true; }
/// <summary> /// Instanciamos los objetos del pull /// </summary> void Start() { poolList = new List <GameObject>(); foreach (GameObject objeto in objectPrefabs) { for (int i = 0; i < objectCount; i++) { GameObject aux = Instantiate(objeto, poolPosition, Quaternion.Euler(0, 0, 0)); PoolElement elem = aux.GetComponent <PoolElement>(); elem.SetPositionPool(aux.transform); elem.SetInactive(); poolList.Add(aux); } } }
private void SetLanes(PoolElement poolElement, Pool pool) { List <Lane> orderedLanes = OrderLanes(pool.Lanes); foreach (Lane lane in orderedLanes) { LaneElement laneElement = new LaneElement(); laneElement.Name = lane.Name; laneElement.Guid = Guid.Parse(lane.Id); NodeGraphicsInfo graphicsInfo = GetNodeGraphicsInfo(lane.NodeGraphicsInfos); if (graphicsInfo != null) { laneElement.Height = graphicsInfo.Height; } poolElement.Lanes.Add(laneElement); } }
///////////////////////////////////////////// Bullet CreateBullet() { Bullet bullet = null; { PoolElement bulletEl = mBulletPool.Create(); if (bulletEl != null) { bullet = bulletEl.gameObject.GetComponent <Bullet>(); } } if (bullet == null) { Debug.LogWarning("Failed to shoot the projectile. Maybe the bullet frefab is wrong?"); } return(bullet); }
public PoolViewModel(DocumentViewModel documentViewModel, PoolElement poolElement) : this(documentViewModel) { _poolElement = poolElement; BaseElement = _poolElement; int count = 0; foreach (LaneElement lane in poolElement.Lanes) { LaneViewModel laneViewModel = new LaneViewModel(count, this, lane); if (count == poolElement.Lanes.Count - 1) { PropertyChanged += laneViewModel.PoolPropertyChanged; } Lanes.Add(laneViewModel); count++; } MinHeight = CalculateMinHeight(); }
/// <summary> /// Creates Xpdl Lanes based on LaneElements inside pool /// </summary> /// <param name="poolElement"></param> /// <returns></returns> private static Lanes GetLanes(PoolElement poolElement) { Lanes lanes = new Lanes(); lanes.Lane = new Lane[poolElement.Lanes.Count]; for (int i = 0; i < poolElement.Lanes.Count; i++) { lanes.Lane[i] = new Lane(); var laneElement = poolElement.Lanes[i]; lanes.Lane[i].Id = laneElement.GetId(); lanes.Lane[i].Name = laneElement.Name; lanes.Lane[i].ParentPool = poolElement.GetId(); lanes.Lane[i].NodeGraphicsInfos = new NodeGraphicsInfos(); lanes.Lane[i].NodeGraphicsInfos.NodeGraphicsInfo = new NodeGraphicsInfo[1]; lanes.Lane[i].NodeGraphicsInfos.NodeGraphicsInfo[0] = CreateNodeGraphicsInfo(laneElement, i); } return(lanes); }
private void DestroyElement(PoolElement element) { if (element.IsActive) { Debug.Log("Something went wrong because an active pool element should not be destroyed from the pool. Think again about destroying pool element as well."); return; } if (poolElementSet.Contains(element)) { poolElementList.Remove(element); poolElementSet.Remove(element); availableElements.Remove(element); Destroy(element.gameObject); } }
private void SpawnElement() { GameObject newClone = Instantiate(clonedPrefab, transform); PoolElement element = newClone.GetComponent <PoolElement>(); if (element == null) { element = newClone.AddComponent <PoolElement>(); } totalSpawnedCount += 1; element.Initialize(totalSpawnedCount, this); poolElementList.Add(element); poolElementSet.Add(element); availableElements.Add(element); }
public GameObject InstantiateElement(Vector3 position, Quaternion rotation) { perUpdateUsageCount += 1; if (availableElements.Count == 0) { ExtendPool(1); } PoolElement selectedElement = availableElements[0]; availableElements.Remove(selectedElement); selectedElement.OnSelectedForInstantiate(position, rotation); //Select an appropriate pooled object from the list. //When get activated fire off OnInstantiate event on element's PoolElement script. return(selectedElement.gameObject); }
///////////////////////////////////////////// public PoolElement Create() { if (mAvailableObjects.Count == 0) { Debug.LogWarning("ObjectPool: no available objects."); return(null); } PoolElement element = mAvailableObjects.Dequeue(); mActiveObjects.Add(element); element.Reset(); Debug.Log("ObjectPool: resuming object " + element.gameObject); #if DEBUG if (mMinimumAvailableElements > mAvailableObjects.Count) { mMinimumAvailableElements = mAvailableObjects.Count; Debug.Log("ObjectPool: Minimum available elements reached: " + mMinimumAvailableElements); } #endif return(element); }
public static void AddModelConnection(ElementsConnectionViewModel connection) { try { PoolElementViewModel startElementViewModel = connection.From as PoolElementViewModel; PoolViewModel poolElementViewModel = startElementViewModel.Pool; PoolElement pool = null; if (poolElementViewModel != null) { pool = startElementViewModel.Pool.BaseElement as PoolElement; } else { pool = startElementViewModel.Document.Document.MainPoolElement; } pool.Connections.Add(connection.Model); } catch (NullReferenceException exception) { throw new ArgumentException("Error while creating connection. Model not found", exception); } }
///////////////////////////////////////////// void SpawnPowerup(Vector3 position) { PoolElement powerup = m_powerups.Create(); powerup.transform.position = position; }
protected override VisualElement CreateElement() { _poolElement = new PoolElement(); Name = "Pool"; return(_poolElement); }