public void GetOrCreateTest()
{
var target = new ActorPool();
var countdownEvent = new CountdownEvent(3);
using (IActor actor = target.GetOrCreate("a"))
{
Task Func()
{
countdownEvent.Signal();
return(Task.CompletedTask);
}
actor.Enqueue(Func);
actor.Enqueue(Func);
actor.Enqueue(Func);
}
countdownEvent.Wait(TimeSpan.FromSeconds(1)).Should().Be(true);
Thread.Sleep(100);
target.EstimatedCount.Should().Be(0);
}
public void multiple_actor_references_should_run_sequentially()
{
// arrange
var random = new Random();
var target = new ActorPool();
int count = 0;
async Task Work()
{
int temp = count;
temp++;
await Task.Yield();
count = temp;
}
var id = Guid.NewGuid().ToString();
// act
Parallel.For(0, 100, _ =>
{
using (IActor actor = target.GetOrCreate(id))
{
Thread.Sleep(random.Next(10));
actor.Enqueue(Work);
}
});
// assert
Thread.Sleep(5);
count.Should().Be(100);
}
internal void Intersect(ref BoundingSphere sphere, List <Actor> result)
{
if (Box.Intersects(ref sphere))
{
if (Children != null)
{
Children[LEFT_TOP_FRONT].Intersect(ref sphere, result);
Children[RIGHT_TOP_FRONT].Intersect(ref sphere, result);
Children[LEFT_TOP_BACK].Intersect(ref sphere, result);
Children[RIGHT_TOP_BACK].Intersect(ref sphere, result);
Children[LEFT_BOTTOM_FRONT].Intersect(ref sphere, result);
Children[RIGHT_BOTTOM_FRONT].Intersect(ref sphere, result);
Children[LEFT_BOTTOM_BACK].Intersect(ref sphere, result);
Children[RIGHT_BOTTOM_BACK].Intersect(ref sphere, result);
}
if (Objects.Count > 0)
{
for (var i = 0; i < Objects.Count; ++i)
{
if (Objects[i].Box.Intersects(ref sphere))
{
ActorPool.Verify(Objects[i].Actor);
result.Add(Objects[i].Actor);
}
}
}
}
}
public void ParallelTest()
{
var random = new Random();
var target = new ActorPool();
int count = 0;
async Task Work()
{
int temp = count;
temp++;
await Task.Yield();
count = temp;
}
Parallel.For(0, 100, _ =>
{
using (var worker = target.GetOrCreate("a"))
{
Thread.Sleep(random.Next(50));
worker.Enqueue(Work);
}
});
Thread.Sleep(5);
count.Should().Be(100);
}
void Awake()
{
_willAcceptTransitions = true;
_actorPool = new ActorPool(false);
_backgroundPool = new BackgroundPool(false);
_pendingAnimations = new Queue <AnimGroup>();
_actorGroup = ActorImage.GetComponent <CanvasGroup>();
}
public void active_actor_should_have_reference()
{
// arrange
var target = new ActorPool();
// act
using var actor = target.GetOrCreate(Guid.NewGuid().ToString());
// assert
target.TakeSnapshot().Count.Should().Be(1);
}
/// <summary>
/// Turn an actorPool.SO into an ActorPoolFinal.SO along with actorDraft's. Takes name of provided ActorPool
/// </summary>
/// <param name="pool"></param>
public void CreateActorPoolFinal(ActorPool pool)
{
if (pool != null)
{
InitialiseActorPoolFinal(pool);
}
else
{
Debug.LogError("Invalid actorPool (Null)");
}
}
/// <summary>
/// Read json file and update actorPool.SO
/// </summary>
/// <param name="pool"></param>
public void ReadActorPool(ActorPool pool)
{
if (pool != null)
{
//get filepath
fileName = pool.name + ".txt";
filePath = Path.Combine(Application.persistentDataPath, fileName);
bool isSuccess = false;
if (string.IsNullOrEmpty(filePath) == false)
{
if (File.Exists(filePath) == true)
{
//read data from File
try { jsonRead = File.ReadAllText(filePath); }
catch (Exception e) { Debug.LogErrorFormat("Failed to read TEXT FROM FILE, error \"{0}\"", e.Message); }
isSuccess = true;
if (isSuccess == true)
{
//read to Save file
try
{
readPool = JsonUtility.FromJson <SaveActorPool>(jsonRead);
Debug.LogFormat("[Fil] FileManager.cs -> ReadActorPool: POOL loaded from \"{0}\"{1}", filePath, "\n");
//update ActorPool.SO with loaded file data
ConvertToActorPool(readPool, pool);
}
catch (Exception e)
{ Debug.LogErrorFormat("Failed to read Json, error \"{0}\"", e.Message); }
}
}
else
{
//file doesn't exist, creat one
WriteActorPool(pool);
}
}
else
{
Debug.LogError("Invalid filename (Null or Empty)");
}
}
else
{
Debug.LogError("Invalid actorPool (Null)");
}
}
public void active_actor_should_have_multiple_reference()
{
// arrange
var target = new ActorPool();
var id = Guid.NewGuid().ToString();
// act
using var actor = target.GetOrCreate(id);
using var actor2 = target.GetOrCreate(id);
// assert
ActorPoolSnapshot snapshot = target.TakeSnapshot();
snapshot.Count.Should().Be(1);
snapshot[id].QueuedWork.Should().Be(0);
snapshot[id].References.Should().Be(2);
}
/// <summary>
/// Converts actor pool, turns into JSON, saves to file
/// </summary>
public void WriteActorPool(ActorPool pool)
{
if (pool != null)
{
//convert SO to save file format
savePool = ConvertFromActorPool(pool);
if (savePool != null)
{
fileName = savePool.poolName + ".txt";
filePath = Path.Combine(Application.persistentDataPath, fileName);
if (string.IsNullOrEmpty(filePath) == false)
{
//convert to Json (NOTE: second, optional, parameter gives pretty output for debugging purposes)
jsonWrite = JsonUtility.ToJson(savePool, true);
//file present? If so delete
if (File.Exists(filePath) == true)
{
try { File.Delete(filePath); }
catch (Exception e) { Debug.LogErrorFormat("Failed to DELETE FILE, error \"{0}\"", e.Message); }
}
//create new file
try { File.WriteAllText(filePath, jsonWrite); }
catch (Exception e) { Debug.LogErrorFormat("Failed to write TEXT FROM FILE, error \"{0}\"", e.Message); }
Debug.LogFormat("[Fil] FileManager.cs -> WriteActorPool: pool Data SAVED to \"{0}\"{1}", filePath, "\n");
}
else
{
Debug.LogError("Invalid fileName (Null or Empty)");
}
}
else
{
Debug.LogErrorFormat("Invalid savePool (Null) for ActorPool \"{0}\"", pool.name);
}
}
else
{
Debug.LogError("Invalid actorPool (Null)");
}
}
public void GetOrCreateShouldReturnWorkingActorWithNoHandles()
{
var target = new ActorPool();
var e = new ManualResetEventSlim(false);
Task Work()
{
e.Wait();
return(Task.CompletedTask);
}
using (var actor = target.GetOrCreate("a"))
{
actor.Enqueue(Work);
}
// this should not block
using var temp = target.GetOrCreate("a");
}
/// <summary>
/// Creates an actorPoolFinal and populates with ActorDraftFinal.SO's.
/// </summary>
/// <param name="pool"></param>
private void InitialiseActorPoolFinal(ActorPool pool)
{
string pathPool, pathDraft;
//
// - - - ActorPool
//
ActorPoolFinal poolAsset = ScriptableObject.CreateInstance <ActorPoolFinal>();
//path with unique asset name for each
pathPool = string.Format("Assets/SO/ActorPoolFinal/{0}.asset", pool.name);
//how many actors required to populate pool
int numToCreate = numOfActors;
poolAsset.nameSet = pool.nameSet;
poolAsset.tag = pool.tag;
poolAsset.side = pool.side;
poolAsset.author = pool.author;
poolAsset.dateCreated = pool.dateCreated;
//
// - - - ActorDraftFinals
//
for (int i = 0; i < numToCreate; i++)
{
//create SO object
ActorDraftFinal actorAsset = ScriptableObject.CreateInstance <ActorDraftFinal>();
//overwrite default data
UpdateActorDraftFinal(pool, poolAsset, actorAsset, i);
//path with unique asset name for each (poolName + counter)
pathDraft = string.Format("Assets/SO/ActorDraftFinal/{0}{1}.asset", pool.name, i);
//delete any existing asset at the same location (if same named asset presnet, new asset won't overwrite)
AssetDatabase.DeleteAsset(pathDraft);
//Add asset to file and give it a name ('actor')
AssetDatabase.CreateAsset(actorAsset, pathDraft);
}
//delete any existing asset at the same location (if same named asset presnet, new asset won't overwrite)
AssetDatabase.DeleteAsset(pathPool);
//initialise pool
AssetDatabase.CreateAsset(poolAsset, pathPool);
//Save assets to disk
AssetDatabase.SaveAssets();
}
public async Task <Dictionary <DateTime, Double> > CalculateMediumTemperatureByActors(Dictionary <DateTime, List <CsvMappingResult <WeatherDetails> > > groupedData, int actorsCount = 1)
{
var res = new Dictionary <DateTime, Double>();
var calculators = new ActorPool(actorsCount);
var taskList = new List <Task <(DateTime, double)> >();
foreach (var entry in groupedData)
{
taskList.Add(calculators.GetActor().Enqueue(() =>
{
return(entry.Key, Value: this.CalculateMedium(entry.Value));
}));
}
await Task.WhenAll(taskList);
foreach (var task in taskList)
{
var(Key, Value) = await task;
res.Add(Key, Value);
}
return(res);
}
/// <summary>
/// Takes a SaveActorPool.cs object and converts to an ActorPool.SO
/// </summary>
/// <param name="pool"></param>
private void ConvertToActorPool(SaveActorPool savePool, ActorPool pool)
{
//hq hierarchy
ConvertToActorDraft(savePool.hqBoss0, pool.hqBoss0);
ConvertToActorDraft(savePool.hqBoss1, pool.hqBoss1);
ConvertToActorDraft(savePool.hqBoss2, pool.hqBoss2);
ConvertToActorDraft(savePool.hqBoss3, pool.hqBoss3);
//hq workers
if (savePool.listHqWorkers.Count == pool.listHqWorkers.Count)
{
for (int i = 0; i < savePool.listHqWorkers.Count; i++)
{
ConvertToActorDraft(savePool.listHqWorkers[i], pool.listHqWorkers[i]);
}
}
else
{
Debug.LogWarningFormat("Mismatch on count -> savePool.listHqWorkers has {0} records, ActorPool.listHqWorkers has {1} records", savePool.listHqWorkers.Count, pool.listHqWorkers.Count);
}
//OnMap
if (savePool.listOnMap.Count == pool.listOnMap.Count)
{
for (int i = 0; i < savePool.listOnMap.Count; i++)
{
ConvertToActorDraft(savePool.listOnMap[i], pool.listOnMap[i]);
}
}
else
{
Debug.LogWarningFormat("Mismatch on count -> savePool.listOnMap has {0} records, ActorPool.listOnMap has {1} records", savePool.listOnMap.Count, pool.listOnMap.Count);
}
//Level One
if (savePool.listLevelOne.Count == pool.listLevelOne.Count)
{
for (int i = 0; i < savePool.listLevelOne.Count; i++)
{
ConvertToActorDraft(savePool.listLevelOne[i], pool.listLevelOne[i]);
}
}
else
{
Debug.LogWarningFormat("Mismatch on count -> savePool.listLevelOne has {0} records, ActorPool.listLevelOne has {1} records", savePool.listLevelOne.Count, pool.listLevelOne.Count);
}
//Level Two
if (savePool.listLevelTwo.Count == pool.listLevelTwo.Count)
{
for (int i = 0; i < savePool.listLevelTwo.Count; i++)
{
ConvertToActorDraft(savePool.listLevelTwo[i], pool.listLevelTwo[i]);
}
}
else
{
Debug.LogWarningFormat("Mismatch on count -> savePool.listLevelTwo has {0} records, ActorPool.listLevelTwo has {1} records", savePool.listLevelTwo.Count, pool.listLevelTwo.Count);
}
//Level Three
if (savePool.listLevelThree.Count == pool.listLevelThree.Count)
{
for (int i = 0; i < savePool.listLevelThree.Count; i++)
{
ConvertToActorDraft(savePool.listLevelThree[i], pool.listLevelThree[i]);
}
}
else
{
Debug.LogWarningFormat("Mismatch on count -> savePool.listLevelThree has {0} records, ActorPool.listLevelThree has {1} records", savePool.listLevelThree.Count, pool.listLevelThree.Count);
}
}
/// <summary>
/// Initialises data for a newly created ActorDraft.
/// </summary>
/// <param name="actor"></param>
private void UpdateActorDraft(ActorPool pool, ActorDraft actor, int num)
{
if (actor != null)
{
//
// - - - name and sex
//
if (Random.Range(0, 100) < 50)
{
actor.sex = sexMale;
actor.firstName = pool.nameSet.firstMaleNames.GetRandomRecord();
}
else
{
actor.sex = sexFemale;
actor.firstName = pool.nameSet.firstFemaleNames.GetRandomRecord();
}
actor.lastName = pool.nameSet.lastNames.GetRandomRecord();
actor.actorName = string.Format("{0} {1}", actor.firstName, actor.lastName);
//
// - - - status, arc, level and power -> assign to actorPool
//
switch (num)
{
case 0:
actor.status = statusHqBoss0;
actor.arc = listOfActorArcs[Random.Range(0, listOfActorArcs.Count)];
actor.sprite = actor.arc.sprite;
actor.power = (numOfActorsHQ + 2 - (int)ActorHQ.Boss) * hqPowerFactor;
actor.level = 3;
actor.trait = GetTrait();
UpdateActorData(actor);
//add to pool (do after all data initialisation)
pool.hqBoss0 = actor;
break;
case 1:
actor.status = statusHqBoss1;
actor.arc = listOfActorArcs[Random.Range(0, listOfActorArcs.Count)];
actor.sprite = actor.arc.sprite;
actor.power = (numOfActorsHQ + 2 - (int)ActorHQ.SubBoss1) * hqPowerFactor;
actor.level = 2;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.hqBoss1 = actor;
break;
case 2:
actor.status = statusHqBoss2;
actor.arc = listOfActorArcs[Random.Range(0, listOfActorArcs.Count)];
actor.sprite = actor.arc.sprite;
actor.power = (numOfActorsHQ + 2 - (int)ActorHQ.SubBoss2) * hqPowerFactor;
actor.level = 2;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.hqBoss2 = actor;
break;
case 3:
actor.status = statusHqBoss3;
actor.arc = listOfActorArcs[Random.Range(0, listOfActorArcs.Count)];
actor.sprite = actor.arc.sprite;
actor.power = (numOfActorsHQ + 2 - (int)ActorHQ.SubBoss3) * hqPowerFactor;
actor.level = 2;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.hqBoss3 = actor;
break;
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
//workers
actor.status = statusHqWorker;
actor.arc = listOfActorArcs[Random.Range(0, listOfActorArcs.Count)];
actor.sprite = actor.arc.sprite;
actor.power = Random.Range(1, 6);
actor.level = 2;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.listHqWorkers.Add(actor);
break;
case 12:
case 13:
case 14:
case 15:
//OnMap
actor.status = statusOnMap;
index = Random.Range(0, listOfTempArcs.Count);
actor.arc = listOfTempArcs[index];
actor.sprite = actor.arc.sprite;
//remove arc from temp list to prevent dupes
listOfTempArcs.RemoveAt(index);
actor.power = 0;
actor.level = 1;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.listOnMap.Add(actor);
//set counter to 0 for remaining level 1 actors using left over temp Arcs
if (num == 15)
{
counter = 0;
}
break;
case 16:
case 17:
case 18:
case 19:
case 20:
//Level one, remaining temp arcs
actor.status = statusPool;
actor.arc = listOfTempArcs[counter++];
actor.sprite = actor.arc.sprite;
actor.power = 0;
actor.level = 1;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.listLevelOne.Add(actor);
//reset counter ready for a full arc set of level one actors
if (num == 20)
{
counter = 0;
}
break;
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
//Level one, an additional full set of 9
actor.status = statusPool;
actor.arc = listOfActorArcs[counter++];
actor.sprite = actor.arc.sprite;
actor.power = 0;
actor.level = 1;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.listLevelOne.Add(actor);
//reset counter ready for a full arc set of level two actors
if (num == 29)
{
counter = 0;
}
break;
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
case 38:
//Level two, a full set of 9
actor.status = statusPool;
actor.arc = listOfActorArcs[counter++];
actor.sprite = actor.arc.sprite;
actor.power = 0;
actor.level = 2;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.listLevelTwo.Add(actor);
//reset counter ready for a full arc set of level three actors
if (num == 38)
{
counter = 0;
}
break;
case 39:
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
//Level three, a full set of 9
actor.status = statusPool;
actor.arc = listOfActorArcs[counter++];
actor.sprite = actor.arc.sprite;
actor.power = 0;
actor.level = 3;
actor.trait = GetTrait();
UpdateActorData(actor);
pool.listLevelThree.Add(actor);
break;
default: Debug.LogWarningFormat("Unrecognised num \"{0}\"", num); break;
}
}
else
{
Debug.LogError("Invalid actorDraft (Null)");
}
}
/// <summary>
/// creates an ActorDraftFinal.SO's using data from supplied ActorDraft.SO
/// </summary>
private void UpdateActorDraftFinal(ActorPool pool, ActorPoolFinal poolFinal, ActorDraftFinal actor, int num)
{
ActorDraft draft = null;
if (actor != null)
{
//
// - - - Get ActorDraft
//
switch (num)
{
//hq hierarchy
case 0: draft = pool.hqBoss0; break;
case 1: draft = pool.hqBoss1; break;
case 2: draft = pool.hqBoss2; break;
case 3: draft = pool.hqBoss3; break;
//hq Workers
case 4: draft = pool.listHqWorkers[0]; break;
case 5: draft = pool.listHqWorkers[1]; break;
case 6: draft = pool.listHqWorkers[2]; break;
case 7: draft = pool.listHqWorkers[3]; break;
case 8: draft = pool.listHqWorkers[4]; break;
case 9: draft = pool.listHqWorkers[5]; break;
case 10: draft = pool.listHqWorkers[6]; break;
case 11: draft = pool.listHqWorkers[7]; break;
//onMap
case 12: draft = pool.listOnMap[0]; break;
case 13: draft = pool.listOnMap[1]; break;
case 14: draft = pool.listOnMap[2]; break;
case 15: draft = pool.listOnMap[3]; break;
//level one, remaining of full set
case 16: draft = pool.listLevelOne[0]; break;
case 17: draft = pool.listLevelOne[1]; break;
case 18: draft = pool.listLevelOne[2]; break;
case 19: draft = pool.listLevelOne[3]; break;
case 20: draft = pool.listLevelOne[4]; break;
//level one, second full set
case 21: draft = pool.listLevelOne[5]; break;
case 22: draft = pool.listLevelOne[6]; break;
case 23: draft = pool.listLevelOne[7]; break;
case 24: draft = pool.listLevelOne[8]; break;
case 25: draft = pool.listLevelOne[9]; break;
case 26: draft = pool.listLevelOne[10]; break;
case 27: draft = pool.listLevelOne[11]; break;
case 28: draft = pool.listLevelOne[12]; break;
case 29: draft = pool.listLevelOne[13]; break;
//level two, full set
case 30: draft = pool.listLevelTwo[0]; break;
case 31: draft = pool.listLevelTwo[1]; break;
case 32: draft = pool.listLevelTwo[2]; break;
case 33: draft = pool.listLevelTwo[3]; break;
case 34: draft = pool.listLevelTwo[4]; break;
case 35: draft = pool.listLevelTwo[5]; break;
case 36: draft = pool.listLevelTwo[6]; break;
case 37: draft = pool.listLevelTwo[7]; break;
case 38: draft = pool.listLevelTwo[8]; break;
//level three, full set
case 39: draft = pool.listLevelThree[0]; break;
case 40: draft = pool.listLevelThree[1]; break;
case 41: draft = pool.listLevelThree[2]; break;
case 42: draft = pool.listLevelThree[3]; break;
case 43: draft = pool.listLevelThree[4]; break;
case 44: draft = pool.listLevelThree[5]; break;
case 45: draft = pool.listLevelThree[6]; break;
case 46: draft = pool.listLevelThree[7]; break;
case 47: draft = pool.listLevelThree[8]; break;
default: Debug.LogWarningFormat("Unrecognised num \"{0}\"", num); break;
}
if (draft != null)
{
//transfer data
UpdateActorDataFinal(actor, draft);
//
// - - - Assign to ActorPoolFinal
//
switch (num)
{
//hq hierarchy
case 0: poolFinal.hqBoss0 = actor; break;
case 1: poolFinal.hqBoss1 = actor; break;
case 2: poolFinal.hqBoss2 = actor; break;
case 3: poolFinal.hqBoss3 = actor; break;
//hq Workers
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
poolFinal.listHqWorkers.Add(actor); break;
//onMap
case 12:
case 13:
case 14:
case 15:
poolFinal.listOnMap.Add(actor); break;
//level one, remaining of full set
case 16:
case 17:
case 18:
case 19:
case 20:
poolFinal.listLevelOne.Add(actor); break;
//level one, second full set
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
poolFinal.listLevelOne.Add(actor); break;
//level two, full set
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
case 38:
poolFinal.listLevelTwo.Add(actor); break;
//level three, full set
case 39:
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
poolFinal.listLevelThree.Add(actor); break;
default: Debug.LogWarningFormat("Unrecognised num \"{0}\"", num); break;
}
}
else
{
Debug.LogError("Invalid actorDraft (Null)");
}
}
else
{
Debug.LogError("Invalid actorDraftFinal (Null)");
}
}
/// <summary>
/// Takes an ActorPool.So and converts to a SaveActorPool.cs file suitable for serialising to file
/// </summary>
/// <param name="pool"></param>
/// <returns></returns>
private SaveActorPool ConvertFromActorPool(ActorPool pool)
{
SaveActorPool poolSave = new SaveActorPool();
if (pool != null)
{
poolSave.poolName = pool.name;
poolSave.hqBoss0 = ConvertFromActorDraft(pool.hqBoss0);
poolSave.hqBoss1 = ConvertFromActorDraft(pool.hqBoss1);
poolSave.hqBoss2 = ConvertFromActorDraft(pool.hqBoss2);
poolSave.hqBoss3 = ConvertFromActorDraft(pool.hqBoss3);
//hq workers
for (int i = 0; i < pool.listHqWorkers.Count; i++)
{
SaveActorDraft draft = ConvertFromActorDraft(pool.listHqWorkers[i]);
if (draft != null)
{
poolSave.listHqWorkers.Add(draft);
}
else
{
Debug.LogErrorFormat("Invalid ActorDraft (Null) for listOfHqWorkers[{0}]", i);
}
}
//onMap
for (int i = 0; i < pool.listOnMap.Count; i++)
{
SaveActorDraft draft = ConvertFromActorDraft(pool.listOnMap[i]);
if (draft != null)
{
poolSave.listOnMap.Add(draft);
}
else
{
Debug.LogErrorFormat("Invalid ActorDraft (Null) for listOfOnMap[{0}]", i);
}
}
//level 1
for (int i = 0; i < pool.listLevelOne.Count; i++)
{
SaveActorDraft draft = ConvertFromActorDraft(pool.listLevelOne[i]);
if (draft != null)
{
poolSave.listLevelOne.Add(draft);
}
else
{
Debug.LogErrorFormat("Invalid ActorDraft (Null) for listOfLevelOne[{0}]", i);
}
}
//level 2
for (int i = 0; i < pool.listLevelTwo.Count; i++)
{
SaveActorDraft draft = ConvertFromActorDraft(pool.listLevelTwo[i]);
if (draft != null)
{
poolSave.listLevelTwo.Add(draft);
}
else
{
Debug.LogErrorFormat("Invalid ActorDraft (Null) for listOfLevelTwo[{0}]", i);
}
}
//level 3
for (int i = 0; i < pool.listLevelThree.Count; i++)
{
SaveActorDraft draft = ConvertFromActorDraft(pool.listLevelThree[i]);
if (draft != null)
{
poolSave.listLevelThree.Add(draft);
}
else
{
Debug.LogErrorFormat("Invalid ActorDraft (Null) for listOfLevelThree[{0}]", i);
}
}
}
else
{
Debug.LogError("Invalid ActorPool (Null)");
}
return(poolSave);
}
