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