public void DeloadAll() { //foreach(Transform child in gameObject.transform) //{ // if(child.gameObject.GetComponent<CubeBehaviour>()) // { // child.gameObject.GetComponent<CubeBehaviour>().SetMaterialColor(-1); // } // child.gameObject.SetActive(false); //} foreach (Transform child in gameObject.transform) { Destroy(child.gameObject); } m_PoolInfoList = null; m_PoolInfoList = new PoolInfo[m_PoolPrefabList.Length]; for (int i = 0; i < m_PoolPrefabList.Length; i++) //Each list { m_PoolInfoList[i] = new PoolInfo(m_PoolPrefabList[i].prefab.name, m_PoolPrefabList[i].prefab, m_PoolPrefabList[i].number, gameObject); } }
private void List_PoolDisplay_SelectionChanged(object sender, SelectionChangedEventArgs e) { tempselectionchanged = e; List_PoolContentDisplay.Items.Clear(); var listbox = (ListBox)sender; if (listbox.Items.Count == 0 || listbox.SelectedIndex == -1) { return; } PoolInfo poolinfo = GetPoolInfo(listbox.SelectedItem); GenerateEditView(poolinfo); if (listbox.SelectedIndex == -1) { return; } if (poolinfo != null && poolinfo.PoolContents != null) { foreach (var item in poolinfo.PoolContents) { List_PoolContentDisplay.Items.Add(item.Name); } } }
public void ReleaseGo(string path, GameObject go, EPoolObjectType type) { if (string.IsNullOrEmpty(path) || go == null) { return; } if (mObjectsPool == null) { mObjectsPool = new GameObject("PoolManager"); mObjectsPool.transform.localPosition = new Vector3(0, -10000, 0); } go.transform.parent = mObjectsPool.transform; PoolInfo poolInfo = null; if (!mPoolDict.TryGetValue(path, out poolInfo)) { poolInfo = new PoolInfo(); mPoolDict.Add(path, poolInfo); } XPoolObj obj = new XPoolObj(); obj.type = type; obj.name = path; obj.gameObject = go; DisablePoolGameObject(go, obj); poolInfo.quene.Enqueue(obj); }
public static Dictionary <string, PoolInfoCfg[]> GetXmlData(string xmlData) { Dictionary <string, PoolInfoCfg[]> m_PoolDataCachedNameDict = new Dictionary <string, PoolInfoCfg[]>(); XmlDocument xml = new XmlDocument(); xml.LoadXml(xmlData); XmlNode ItemsNode = xml.DocumentElement; foreach (XmlNode node in ItemsNode.ChildNodes) { if (node.Attributes.Count > 0) { string scaneName = node.Attributes.GetNamedItem("name").Value; List <PoolInfoCfg> list = PoolInfo.ParseSceneData(node); if (null != list && !m_PoolDataCachedNameDict.ContainsKey(scaneName)) { m_PoolDataCachedNameDict.Add(scaneName, list.ToArray()); } } } return(m_PoolDataCachedNameDict); }
/// <summary> /// 添加加载信息,带有组信息 /// </summary> /// <param name="_prefab">对象预制体</param> /// <param name="_capacity">对象池容量</param> /// <param name="_preload">是否预加载</param> /// <param name="_group">组名</param> public void AddLoadInfo(GameObject _prefab, int _capacity, bool _preload, string _group) { if (_prefab == null || _prefab.Equals(null)) { return; } if (list_poolInfo == null) { list_poolInfo = new List <PoolInfo> (); } PoolInfo info = list_poolInfo.Find(item => item.prefab.Equals(_prefab)); if (info == null) { info = new PoolInfo(); list_poolInfo.Add(info); info.prefab = _prefab; } info.capacity = _capacity; info.preload = _preload; info.group = _group; }
void Awake() { Debug.Log("Awake GameManager"); if (instance == null) { instance = this; DontDestroyOnLoad(instance.gameObject); name = "PoolManager"; if (!InitGame()) { Debug.LogError("Unable to create PoolManager!"); } } else { Debug.LogError("PoolManager already exists!"); } m_PoolInfoList = new PoolInfo[m_PoolPrefabList.Length]; for (int i = 0; i < m_PoolPrefabList.Length; i++) //Each list { m_PoolInfoList[i] = new PoolInfo(m_PoolPrefabList[i].prefab.name, m_PoolPrefabList[i].prefab, m_PoolPrefabList[i].number, gameObject); } }
// Token: 0x06012670 RID: 75376 RVA: 0x004B99DC File Offset: 0x004B7BDC public void CreateItemListPool(int poolSize) { if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_CreateItemListPoolInt32_hotfix != null) { this.m_CreateItemListPoolInt32_hotfix.call(new object[] { this, poolSize }); return; } BJLuaObjHelper.IsSkipLuaHotfix = false; PoolInfo poolInfoByName = this.RankListItemPool.GetPoolInfoByName("RankingListItemUIPrefab"); poolInfoByName.poolSize = poolSize; poolInfoByName.prefab = this.m_itemTemplete; this.RankListItemPool.CreatePools(); Stack <PoolObject> objectPoolByName = this.RankListItemPool.GetObjectPoolByName("RankingListItemUIPrefab"); foreach (PoolObject poolObject in objectPoolByName) { RankingListItemUIController component = poolObject.GetComponent <RankingListItemUIController>(); component.Init(); component.RegisterItemNeedFillEvent(new Action <UIControllerBase>(this.OnRankItemFill)); } }
public PensionFundContract CheckContractCreationTransaction(String transactionHash) { var pensionFundContract = Data.GetPensionFundContract(transactionHash); if (pensionFundContract == null) { throw new ArgumentException("Invalid transaction hash."); } Transaction demoContractTransaction = EthereumManager.GetTransaction(transactionHash); if (demoContractTransaction == null) { if (pensionFundContract.CreationDate < DateTime.UtcNow.AddMinutes(PensionFundTransactionBusiness.BLOCKCHAIN_TRANSACTION_TOLERANCE)) { PoolInfo poolInfo = GetPoolInfo(); if (!poolInfo.Pending.Contains(pensionFundContract.TransactionHash)) { Logger.LogError(string.Format("Transaction for creation contract {0} is lost.", pensionFundContract.TransactionHash)); List <PensionFundReferenceContract> referenceDistribution = PensionFundReferenceContractBusiness.List(pensionFundContract.TransactionHash); if (!referenceDistribution.Any()) { throw new Exception("Reference contract cannot be found."); } PensionFund pensionFund = PensionFundBusiness.GetByTransaction(pensionFundContract.TransactionHash); if (pensionFund == null) { throw new Exception("Pension fund cannot be found."); } pensionFund.Option.Company.BonusDistribution = BonusDistributionBusiness.List(pensionFund.Option.Company.Address); if (!pensionFund.Option.Company.BonusDistribution.Any()) { throw new ArgumentException("Bonus distribution cannot be found."); } PensionFundReferenceContractBusiness.Delete(pensionFundContract.TransactionHash); Delete(pensionFundContract); pensionFundContract = Create(pensionFund.Option.Address, pensionFund.Option.Company.Address, pensionFund.Option.Company.Employee.Address, pensionFund.Option.Fee, pensionFund.Option.LatePenalty, pensionFund.Option.Company.MaxSalaryBonusRate, pensionFund.Option.Company.Employee.Contribution, pensionFund.Option.Company.BonusRate, pensionFund.Option.Company.Employee.Salary, referenceDistribution.ToDictionary(c => c.ReferenceContractAddress, c => c.Percentage), pensionFund.Option.Company.BonusDistribution.ToDictionary(c => c.Period, c => c.ReleasedBonus)); foreach (PensionFundReferenceContract reference in referenceDistribution) { PensionFundReferenceContractBusiness.Create(pensionFundContract.TransactionHash, reference.ReferenceContractAddress, reference.Percentage); } } } return(pensionFundContract); } else { pensionFundContract = UpdateAfterMined(pensionFundContract, demoContractTransaction); } return(pensionFundContract); }
//Equalivant to Destroy(gameObject). public void DestroyGameObject(GameObject instance) { //Null check in case you are leisurely trying to destroy an object that has been removed from EXISTENCE, not sure how.. if (instance != null) { if (onDestroyed != null) { onDestroyed.Invoke(instance); } //If the instance is part of the pool if (IPDictionary.ContainsKey(instance)) { //Add it back into the pool as available GameObject prefab = IPDictionary[instance]; PoolInfo poolInfo = poolDictionary[prefab]; poolInfo.AddToPool(instance); //Hide gameobject instance.SetActive(false); } else { //Otherwise use Unity Destroy Destroy(instance); } } }
public GameObject GetGO(string resName) { PoolInfo poolInfo = null; if (!poolInfoDic.TryGetValue(resName, out poolInfo)) { poolInfo = new PoolInfo(); poolInfoDic.Add(resName, poolInfo); } GameObject go = null; ObjectInfo objectInfo = null; foreach (KeyValuePair <GameObject, ObjectInfo> pair in poolInfo.objectsDic) { go = pair.Key; objectInfo = pair.Value; break; } if (go == null) { var loadedObj = App.resManager.LoadRes(resName); // instantiate one. go = GameObject.Instantiate(loadedObj) as GameObject; } else { poolInfo.objectsDic.Remove(go); OnGet(go, objectInfo); } return(go); }
// 添加新的对象池 private void AddPool(PoolInfo poolInfo) { if (poolInfo.prefab == null) { Debug.Log("pool manager: attempt add null"); return; } if (poolsDict.ContainsKey(poolInfo.prefab.name)) { Debug.Log($"pool manager: 尝试添加已存在的 {poolInfo.prefab.name} prefab"); return; } //用poolHolder来组织实例, 并将它放在PoolManager节点下 poolInfo.holder = new GameObject(poolInfo.prefab.name + "Pool").transform; poolInfo.holder.SetParent(transform); poolInfo.pool = new Queue <GameObject>(); for (int i = 0; i < poolInfo.initCount; i++) { GameObject instance = Instantiate(poolInfo.prefab, poolInfo.holder); instance.SetActive(false); poolInfo.pool.Enqueue(instance); } poolsDict.Add(poolInfo.prefab.name, poolInfo); }
static int OnClickList(IntPtr L) { LuaScriptMgr.CheckArgsCount(L, 1); PoolInfo obj = (PoolInfo)LuaScriptMgr.GetUnityObjectSelf(L, 1, "PoolInfo"); obj.OnClickList(); return(0); }
/// <summary> /// 从传入的info中,根据序列数返回PoolContent /// </summary> /// <param name="item">获取的ListBoxItem</param> /// <param name="info"></param> /// <returns></returns> public PoolContent GetPoolContent(object item, PoolInfo info) { if (info == null || item == null) { return(null); } return(info.PoolContents[List_PoolContentDisplay.Items.IndexOf(item)]); }
void FillPool(PoolInfo info) { for (int i = 0; i < info.amount; i++) { obj = Instantiate(info.prefab); obj.gameObject.SetActive(false); info.pool.Add(obj); } }
static int showTiShi(IntPtr L) { LuaScriptMgr.CheckArgsCount(L, 2); PoolInfo obj = (PoolInfo)LuaScriptMgr.GetUnityObjectSelf(L, 1, "PoolInfo"); string arg0 = LuaScriptMgr.GetLuaString(L, 2); obj.showTiShi(arg0); return(0); }
private List <GameObject> mDestroyPoolGameObjects = new List <GameObject>();//删除队列 private bool TryGetObject(PoolInfo poolInfo, ref XPoolObj obj) { if (poolInfo.quene.Count > 0) { obj = poolInfo.quene.Dequeue(); return(true); } return(false); }
//Listing a new prefab to the pool list. public void ListNewPrefab(GameObject prefab, int amount) { if (!poolDictionary.ContainsKey(prefab)) { PoolInfo newPoolInfo = new PoolInfo(prefab.name, prefab, amount); poolDictionary.Add(prefab, newPoolInfo); poolInfoList.Add(newPoolInfo); newPoolInfo.InitPool(this); } }
static int show(IntPtr L) { LuaScriptMgr.CheckArgsCount(L, 3); PoolInfo obj = (PoolInfo)LuaScriptMgr.GetUnityObjectSelf(L, 1, "PoolInfo"); string arg0 = LuaScriptMgr.GetLuaString(L, 2); List <JSONObject> arg1 = (List <JSONObject>)LuaScriptMgr.GetNetObject(L, 3, typeof(List <JSONObject>)); obj.show(arg0, arg1); return(0); }
void FillPool(PoolInfo info) { for (int i = 0; i < info.amount; i++) { GameObject obInstance = null; obInstance = Instantiate(info.prefab, info.cotainer.transform); obInstance.gameObject.SetActive(false); obInstance.transform.position = defaultPos; info.pool.Add(obInstance); } }
void Start() { m_PoolInfoList = new PoolInfo[m_PoolPrefabList.Length]; for (int i = 0; i < m_PoolPrefabList.Length; i++) //Each list { m_PoolInfoList[i] = new PoolInfo(m_PoolPrefabList[i].prefab.name, m_PoolPrefabList[i].prefab, m_PoolPrefabList[i].number, gameObject); } }
public void CoolObject(GameObject obj, int idPool) { obj.SetActive(false); selected = GetPoolById(idPool); poolSelected = selected.pool; if (!poolSelected.Contains(obj)) { poolSelected.Add(obj); } }
public GameObject GetFromPool(int poolIndex, Vector2 position) { PoolInfo poolInfo = poolInfos[poolIndex]; GameObject _object = poolInfo.pool[poolInfo.index]; _object.SetActive(true); _object.transform.position = position; poolInfo.index = (poolInfo.index + 1) % poolInfo.size; poolInfos[poolIndex].index = poolInfo.index; return(_object); }
public void CoolObject(GameObject ob, PoolObjectType type) { ob.SetActive(false); ob.transform.position = defaultPos; PoolInfo selected = GetPoolByType(type); List <GameObject> pool = selected.pool; if (!pool.Contains(ob)) { pool.Add(ob); } }
/// <summary> /// 给出内存池的详细信息 /// </summary> /// <param name="strName"></param> /// <param name="iFreeCount"></param> /// <param name="iInitialCapacity"></param> /// <param name="iCurrentCapacity"></param> /// <param name="iMisses"></param> public PoolInfo GetPoolInfo() { PoolInfo poolInfo = new PoolInfo(); // 可以不需要锁定的,因为只是给出没有修改数据 poolInfo.Name = m_Name; poolInfo.FreeCount = m_FreePool.Count; poolInfo.InitialCapacity = m_InitialCapacity; poolInfo.CurrentCapacity = m_InitialCapacity * (1 + m_Misses); // m_Misses是从零开始计算的因此需加1 poolInfo.Misses = m_Misses; //poolInfo.ReleaseCount = return(poolInfo); }
private int m_PoolInfoCount = 0; // プール使用個数. public PoolInfo searchPoolInfo(ParticleSystem key_particle_system) { for (int idx = 0; idx < m_PoolInfoCount; idx++) { PoolInfo pool_info = m_PoolInfos[idx]; if (pool_info.getKey() == key_particle_system) { return(pool_info); } } return(null); }
public void createPoolInfo(ParticleSystem key_particle_system, int pool_num, int effect_max) { PoolInfo pool_info = searchPoolInfo(key_particle_system); if (pool_info == null) { if (m_PoolInfoCount < m_PoolInfos.Length) { pool_info = new PoolInfo(key_particle_system, pool_num, effect_max); m_PoolInfos[m_PoolInfoCount] = pool_info; m_PoolInfoCount++; } } }
/// <summary> /// 注册一个新的对象池 /// </summary> public void RegisterNewPool(PoolInfo poolInfo) { #region 必须项检测 if (poolInfo == null) { Logger.Error($"注册对象池时,对象池信息为空。"); return; } if (string.IsNullOrEmpty(poolInfo.PoolName)) { Logger.Error($"注册对象池时,对象池名字为空。"); return; } if (string.IsNullOrEmpty(poolInfo.TagName)) { Logger.Error($"注册对象池时,对象池{poolInfo.PoolName}标签为空。"); return; } if (poolInfo.Prefab == null) { Logger.Warning($"注册对象池时,对象预设体为空,此对象池{poolInfo.PoolName}不会自动生成对象。"); } #endregion if (IsRegisterPool(poolInfo.PoolName)) { Logger.Error($"该对象池{poolInfo.PoolName}已经注册过了,请勿重复注册,可以执行{nameof(UnRegisterPool)}方法销毁已有对象池。"); return; } _poolNameForPoolTagDictionary.Add(poolInfo.PoolName, poolInfo.TagName); GameObjectPoolDictionary pools; if (!_tagedPools.TryGetValue(poolInfo.TagName, out pools)) { pools = new GameObjectPoolDictionary(); _tagedPools.Add(poolInfo.TagName, pools); } GameObjectPool pool; if (poolInfo.RecordOutPoolObject) { pool = new RecordableGameObjectPool(poolInfo, transform); } else { pool = new GameObjectPool(poolInfo, transform); } pools.Add(poolInfo.PoolName, pool); Count++; }
protected PoolInfo GetPoolInfo() { PoolInfo poolInfo = EthereumManager.GetPoolInfo(); if (poolInfo.Queued.Count > 0) { Logger.LogError(string.Format("Pool problem. {0} queued messages.", poolInfo.Queued.Count)); } if (poolInfo.Pending.Count > 120) { Logger.LogError("Pool critical use. More then 120 pending messages."); } return(poolInfo); }
/// <summary> /// 开始加载所有加载信息 /// </summary> public void StartLoadAllInfos() { if (list_poolInfo == null) { return; } for (int i = 0; i < list_poolInfo.Count; i++) { PoolInfo info = list_poolInfo[i]; LoadPool(info.prefab, info.capacity, info.preload, info.group); } list_poolInfo.Clear(); list_poolInfo = null; }
public async Task <IActionResult> GetPoolInfoAsync() { var minimumActiveTime = DateTimeOffset.UtcNow - TimeSpan.FromMinutes(1); var poolInfo = new PoolInfo() { Name = CustomizationOptions.PoolName, TotalMinerCount = await DbContext.Miners.CountAsync(), TotalPlotCount = await DbContext.Miners.SumAsync(x => x.LastPlotCount), ActiveMinerCount = await DbContext.Miners.CountAsync(x => x.NextIncrement >= minimumActiveTime), ActivePlotCount = await DbContext.Miners.Where(x => x.NextIncrement >= minimumActiveTime).SumAsync(x => x.LastPlotCount), }; return(Ok(poolInfo)); }
public void InitPool(string poolName, GameObject poolPrefab, int amount, bool grow) { List<GameObject> objects = new List<GameObject>(); PoolInfo pi = new PoolInfo(); pi.pooledAmount = amount; pi.pooledObject = poolPrefab; pi.willGrow = grow; if (!pool.ContainsKey(poolName)) { for (int i = 0; i < amount; i++) { GameObject obj = GameObject.Instantiate(poolPrefab); obj.SetActive(false); objects.Add(obj); } pool.Add(poolName, objects); poolInfoContainer.Add(poolName,pi); } }