public void AddEntry(LootStoreItem item)
{
if (item.chance != 0)
ExplicitlyChanced.Add(item);
else
EqualChanced.Add(item);
}
PoolObject RollOne(ActivePoolData spawns, ulong triggerFrom)
{
if (!ExplicitlyChanced.Empty())
{
float roll = (float)RandomHelper.randChance();
for (int i = 0; i < ExplicitlyChanced.Count; ++i)
{
roll -= ExplicitlyChanced[i].chance;
// Triggering object is marked as spawned at this time and can be also rolled (respawn case)
// so this need explicit check for this case
if (roll < 0 && (ExplicitlyChanced[i].guid == triggerFrom || !spawns.IsActiveObject <T>(ExplicitlyChanced[i].guid)))
{
return(ExplicitlyChanced[i]);
}
}
}
if (!EqualChanced.Empty())
{
int index = RandomHelper.IRand(0, EqualChanced.Count - 1);
// Triggering object is marked as spawned at this time and can be also rolled (respawn case)
// so this need explicit check for this case
if (EqualChanced[index].guid == triggerFrom || !spawns.IsActiveObject <T>(EqualChanced[index].guid))
{
return(EqualChanced[index]);
}
}
return(null);
}
public void AddEntry(PoolObject poolitem, uint maxentries)
{
if (poolitem.chance != 0 && maxentries == 1)
{
ExplicitlyChanced.Add(poolitem);
}
else
{
EqualChanced.Add(poolitem);
}
}
public void RemoveOneRelation(uint child_pool_id)
{
if (typeof(T).Name != "Pool")
{
return;
}
foreach (var poolObject in ExplicitlyChanced)
{
if (poolObject.guid == child_pool_id)
{
ExplicitlyChanced.Remove(poolObject);
break;
}
}
foreach (var poolObject in EqualChanced)
{
if (poolObject.guid == child_pool_id)
{
EqualChanced.Remove(poolObject);
break;
}
}
}
public bool isEmpty()
{
return(ExplicitlyChanced.Empty() && EqualChanced.Empty());
}
public void SpawnObject(ActivePoolData spawns, uint limit, ulong triggerFrom)
{
if (typeof(T).Name == "Quest")
{
SpawnQuestObject(spawns, limit, triggerFrom);
return;
}
int count = (int)(limit - spawns.GetActiveObjectCount(poolId));
// If triggered from some object respawn this object is still marked as spawned
// and also counted into m_SpawnedPoolAmount so we need increase count to be
// spawned by 1
if (triggerFrom != 0)
{
++count;
}
// This will try to spawn the rest of pool, not guaranteed
if (count > 0)
{
List <PoolObject> rolledObjects = new List <PoolObject>();
// roll objects to be spawned
if (!ExplicitlyChanced.Empty())
{
while (count != 0 && ExplicitlyChanced.Count > rolledObjects.Count)
{
--count;
float roll = (float)RandomHelper.randChance();
foreach (PoolObject obj in ExplicitlyChanced)
{
roll -= obj.chance;
// Triggering object is marked as spawned at this time and can be also rolled (respawn case)
// so this need explicit check for this case
if (roll < 0 && (obj.guid == triggerFrom || !spawns.IsActiveObject <T>(obj.guid)))
{
rolledObjects.Add(obj);
break;
}
}
}
}
else if (!EqualChanced.Empty())
{
rolledObjects = EqualChanced;
for (var i = 0; i < rolledObjects.Count; ++i)
{
var obj = rolledObjects[i];
// remove most of the active objects so there is higher chance inactive ones are spawned
if (spawns.IsActiveObject <T>(obj.guid) && RandomHelper.URand(1, 4) != 1)
{
rolledObjects.Remove(obj);
}
}
rolledObjects.RandomResize((uint)count);
}
// try to spawn rolled objects
foreach (PoolObject obj in rolledObjects)
{
if (spawns.IsActiveObject <T>(obj.guid))
{
continue;
}
if (obj.guid == triggerFrom)
{
ReSpawn1Object(obj);
triggerFrom = 0;
}
else
{
spawns.ActivateObject <T>(obj.guid, poolId);
Spawn1Object(obj);
}
}
}
// One spawn one despawn no count increase
if (triggerFrom != 0)
{
DespawnObject(spawns, triggerFrom);
}
}
