public void SyncWorkingSpawnData()
{
WorkingWaveData.Clear();
spawnParent.SortChildrenByName();
for (int i = 0; i < spawnParent.childCount; i++)
{
Transform waveParent = spawnParent.GetChild(i);
PLESpawn spawn = waveParent.GetComponent <PLESpawn>();
if (spawn != null)
{
AddSpawnData(waveParent, 0);//keira
}
else //any other baddy
{
int waveChildCount = waveParent.childCount;
for (int j = 0; j < waveParent.childCount; j++)
{
Transform spawnUI = waveParent.GetChild(j);
if (spawnUI)
{
AddSpawnData(spawnUI, i - 1);
}
}
}
}
}
void RaycastItems(Ray r, bool hitUI)
{
RaycastHit[] hits = Physics.RaycastAll(r, 1000.0f);
HitItem = hits.Length > 0;
if (hitUI)
{
HitItem = false;
}
System.Predicate <string> nameCheck = hitName => !hitName.Contains(Strings.BLOCKINGOBJECT) && !hitName.Contains("Wall") && !hitName.Contains(Strings.PREVIEW);
raycastHit = HitItem ? GetClosestHit(hits, nameCheck) : null;
if (HitItem)
{
if (raycastHit == null)
{
raycastHit = hits[0];
}
currentMouseWorldPosition = raycastHit.Value.transform.position;
currentHoveredObject = raycastHit.Value.transform.gameObject;
currentItem = currentHoveredObject.GetComponent <PLEItem>();
currentProp = currentHoveredObject.GetComponent <PLEProp>();
currentSpawn = currentHoveredObject.GetComponent <PLESpawn>();
}
else
{
currentHoveredObject = null;
currentProp = null;
currentSpawn = null;
currentItem = null;
}
}
protected override void PostSelectUIItemMenuSpecific(GameObject newItem)
{
base.PostSelectUIItemMenuSpecific(newItem);
PLESpawn spawn = newItem.GetComponent <PLESpawn>();
UpdateAllFields(spawn.totalSpawnAmount, spawn.MinSpawns, spawn.DisplayName.ToUpper(), spawn.iconPreview);
int remainingSpawns = RemainingSpawnsInCurrentWave(spawn);
UpdateAvailableField(remainingSpawns);
}
public int GetRequiredKillCountInCurrentWave(PLESpawn spawn)
{
int maxMinSpawnsAllowed = GetMaxMinSpawnsAllowedCurrentInWave(spawn);
if (CurrentWaveIndex == MaxWaveIndex && !InfiniteWavesEnabled)
{
return(maxMinSpawnsAllowed);
}
return(Mathf.Clamp(maxMinSpawnsAllowed - spawn.MinSpawns, 0, maxMinSpawnsAllowed));
}
public int MinNumSpawns(SpawnType spawnType, int waveIndex)
{
List <PLESpawn> spawns = GetPLESpawnsFromWave(waveIndex);
PLESpawn spawn = spawns.Find(item => item.spawnType == spawnType);
if (spawn)
{
return(spawn.MinSpawns);
}
return(0);
}
protected override void PostPlaceItem(GameObject newItem)
{
int currentWaveIndex = PLESpawnManager.Instance.CurrentWaveIndex;
int maxWaveIndex = PLESpawnManager.Instance.MaxWaveIndex;
Transform waveParent = levelEditor.TryCreateWaveParent(currentWaveIndex);
for (int i = maxWaveIndex; i >= 0; i--)
{
levelEditor.TryCreateWaveParent(i);
}
newItem.transform.SetParent(waveParent);
MouseHelper.currentBlockUnit.AddSpawn(newItem);
if (newItem.CompareTag(Strings.Editor.PLAYER_SPAWN_TAG))
{
if (playerSpawnInstance != null)
{
DestroyImmediate(playerSpawnInstance);
}
playerSpawnInstance = newItem;
playerSpawnInstance.transform.SetParent(levelEditor.TryCreateWaveParent(0).parent);
}
PLESpawn newSpawn = newItem.GetComponent <PLESpawn>();
if (newSpawn)
{
int spawnAmount = newSpawn.totalSpawnAmount;
UpdateMinSpawnAmounts(newSpawn);
int requiredAmount = GetRequiredKillCountInCurrentWave(newSpawn);
ChangeSpawnAmountsInternally(spawnAmount, requiredAmount, false);
int remainingSpawns = RemainingSpawnsInCurrentWave(newSpawn);
UpdateAvailableField(remainingSpawns);
SelectGameItem(newSpawn);
//if (!SpawnManager.SpawnsUnderMaximum(newSpawn)) {
// DeselectItem();
// DeselectUIItem();//destroys preview gameobject too
//}
if (newSpawn.spawnType == SpawnType.Keira)
{
PLEUIItem firstAvailable = scrollGroup.TryGetFirstAvailableUIItem();
if (firstAvailable)
{
selectedPreviewImage.sprite = firstAvailable.imagePreview.sprite;
scrollGroup.SelectUIItem(firstAvailable.ItemIndex, false);
}
}
}
mainPLEMenu.SetMenuButtonInteractabilityByState();
}
protected override void InitializeUI()
{
base.InitializeUI();
List <PLESpawn> spawns = new List <PLESpawn>();
pleItems.ForEach(item => {
PLESpawn spawn = item as PLESpawn;
if (spawn != null && spawn.spawnType != SpawnType.Keira)
{
spawns.Add(spawn);
}
});
PLESpawnManager.Instance.SetSpawnTypes(spawns);
}
private void Reset(params object[] parameters)
{
List <PLESpawn> currentWaveSpawners = WorkingLevelData.GetPLESpawnsFromWave(CurrentWaveIndex);
for (int i = 0; i < currentWaveSpawners.Count; i++)
{
PLESpawn spawn = currentWaveSpawners[i];
spawn.SetOnCriticalEnemiesDead(null);
}
FindObjectsOfType <EnemyBase>().ToList().ForEach(enemy => { enemy.OnDeath(); });
CurrentWaveIndex = 0;
infiniteWaveIndex = 0;
hasCycledLevel = false;
}
private void CallWave(int waveIndex)
{
CurrentWaveIndex = waveIndex;
editorInstance.EnableCurrentWaveSpawnParents(waveIndex);
List <PLESpawn> currentWaveSpawners = WorkingLevelData.GetPLESpawnsFromWave(waveIndex);
for (int i = 0; i < currentWaveSpawners.Count; i++)
{
PLESpawn spawn = currentWaveSpawners[i];
spawn.SetOnCriticalEnemiesDead(OnCriticalSpawnsInSpawnerDead);
spawn.StartSpawning();
}
EventSystem.Instance.TriggerEvent(Strings.Events.PLE_CALL_WAVE, waveIndex);
EventSystem.Instance.TriggerEvent(Strings.Events.WAVE_COMPLETE, infiniteWaveIndex);
}
public int GetNumberSpawnsInNextWave(PLESpawn spawn)
{
int numSpawnsInNextWave = 0;
int currentIndex = CurrentWaveIndex;
int nextIndex = currentIndex + 1;
if (nextIndex > MaxWaveIndex && InfiniteWavesEnabled)
{
nextIndex = 0;
}
if (nextIndex <= MaxWaveIndex)
{
numSpawnsInNextWave = WorkingLevelData.NumSpawns(spawn.spawnType, nextIndex);
}
return(numSpawnsInNextWave);
}
private int UpdateMinSpawnAmounts(PLESpawn newSpawn)
{
List <PLESpawn> allVisibleSpawns = FindObjectsOfType <PLESpawn>().ToList();
int minSpawnAmount = 0;
if (allVisibleSpawns.Count > 1)
{
PLESpawn existingMatchingType = allVisibleSpawns.Find(spawn => spawn.spawnType == newSpawn.spawnType && spawn != newSpawn && !spawn.gameObject.name.Contains(Strings.PREVIEW));
if (existingMatchingType != null)
{
minSpawnAmount = existingMatchingType.MinSpawns;
}
}
newSpawn.MinSpawns = minSpawnAmount;
return(minSpawnAmount);
}
private void LoadSpawnsAllOn()
{
List <string> spawnNames = new List <string>();
List <GameObject> spawnObjects = Resources.LoadAll <GameObject>(Strings.Editor.SPAWN_OBJECTS_PATH).ToList();
List <PLESpawn> pleSpawns = spawnObjects.Select(spawn => spawn.GetComponent <PLESpawn>()).ToList();
List <PLESpawn> spawnedPLEs = new List <PLESpawn>();
for (int i = 0; i < WorkingWaveData.Count; i++)
{
GameObject waveParent = new GameObject(GetWaveName(i));
waveParent.transform.SetParent(spawnParent);
for (int j = 0; j < WorkingWaveData[i].spawnData.Count; j++)
{
SpawnData spawnData = WorkingWaveData[i].spawnData[j];
int minSpawns = WorkingWaveData[i].GetMinSpawns(spawnData.SpawnType);
GameObject enemyUIPrefabToSpawn = pleSpawns.Find(spawn => (int)(spawn.spawnType) == spawnData.spawnType).gameObject;
Transform newSpawnTransform = Instantiate(enemyUIPrefabToSpawn, waveParent.transform, false).transform;
newSpawnTransform.name = newSpawnTransform.name.TryCleanName(Strings.CLONE);
spawnNames.Add(newSpawnTransform.name);
PLESpawn pleSpawn = newSpawnTransform.GetComponent <PLESpawn>();
spawnData.pleSpawn = pleSpawn;
spawnedPLEs.Add(pleSpawn);
pleSpawn.minSpawns = minSpawns;
pleSpawn.totalSpawnAmount = spawnData.count;
pleSpawn.spawnType = (SpawnType)spawnData.spawnType;
pleSpawn.tile = levelEditor.gridController.GetTileAtPoint(spawnData.position.AsVector);
newSpawnTransform.position = spawnData.position.AsVector;
}
}
System.Predicate <PLESpawn> keiraSpawn = spawn => spawn.spawnType == SpawnType.Keira;
if (spawnedPLEs.Exists(keiraSpawn))
{
Transform keiraSpawnTransform = spawnedPLEs.Find(keiraSpawn).transform;
keiraSpawnTransform.SetParent(spawnParent);
keiraSpawnTransform.SetAsFirstSibling();
SpawnMenu.playerSpawnInstance = keiraSpawnTransform.gameObject;
}
if (SceneTracker.IsCurrentSceneEditor)
{
(mainPLEMenu.GetMenu(PLEMenuType.SPAWN) as SpawnMenu).ResetMenu(spawnNames);
}
}
protected override void DeleteHoveredItem()
{
PLESpawn currentSpawn = MouseHelper.currentSpawn;
PLESpawn existingMatchingType = null;
List <PLESpawn> allVisibleSpawns = FindObjectsOfType <PLESpawn>().ToList();
if (allVisibleSpawns.Count > 1)
{
existingMatchingType = allVisibleSpawns.Find(spawn => spawn.spawnType == currentSpawn.spawnType && spawn != currentSpawn);
}
base.DeleteHoveredItem();
mainPLEMenu.SetMenuButtonInteractabilityByState();
if (existingMatchingType != null)
{
existingMatchingType.MinSpawns = Mathf.Clamp(existingMatchingType.MinSpawns, 0, GetMaxMinSpawnsAllowedInCurrentWave(existingMatchingType));
}
}
public int GetMaxSpawnsAllowedInWave(PLESpawn spawn, int waveIndex)
{
waveIndex = Mathf.Clamp(waveIndex, 0, MaxWaveIndex);
int previousWaveIndex = waveIndex - 1;
int previousWaveMinSpawnCount = 0;
if (previousWaveIndex < 0 && InfiniteWavesEnabled)
{
previousWaveIndex = MaxWaveIndex;
}
if (previousWaveIndex >= 0)
{
previousWaveMinSpawnCount = WorkingLevelData.MinNumSpawns(spawn.spawnType, previousWaveIndex);
}
int max = spawn.MaxPerWave - previousWaveMinSpawnCount;
return(Mathf.Clamp(max, 0, spawn.MaxPerWave));
}
private void AddSpawnData(Transform spawnUI, int waveIndex)
{
waveIndex = Mathf.Max(waveIndex, 0);
PLESpawn spawn = spawnUI.GetComponent <PLESpawn>();
int spawnType = (int)spawn.spawnType;
int spawnCount = spawn.totalSpawnAmount;
SpawnData spawnData = new SpawnData(spawnType, spawnCount, spawnUI.position)
{
pleSpawn = spawn
};
while (WorkingWaveData.Count <= waveIndex)
{
WorkingWaveData.Add(new WaveData());
}
WorkingWaveData[waveIndex].spawnData.Add(spawnData);
WorkingWaveData[waveIndex].SetMinSpawns(spawnType, spawn.MinSpawns);
}
public void HandleSpawnUIInteractability()
{
TryInitialize();
pleUIItems.ForEach(item => {
PLESpawn spawn = item.pleItem as PLESpawn;
bool isInteractable = PLESpawnManager.Instance.SpawnsUnderMaximum(spawn);
item.ToggleInteractable(isInteractable);
});
bool keiraExists = SpawnMenu.playerSpawnInstance != null;
KeiraUIItem.ToggleInteractable(!keiraExists);
//PLEUIItem lastItem = GetLastUIItem();
//if (!lastItem.isInteractable) {
// placementMenu.TrySelectFirstAvailable();
//}
}
public int GetMaxSpawnsAllowedInCurrentWave(PLESpawn spawn)
{
return(GetMaxSpawnsAllowedInWave(spawn, CurrentWaveIndex));
}
public int RemainingSpawnsAllowedInCurrentWave(PLESpawn spawn)
{
return(GetMaxSpawnsAllowedInCurrentWave(spawn) - NumberSpawnsInCurrentWave(spawn.spawnType));
}
public bool SpawnsUnderMaximum(PLESpawn spawn)
{
return(NumberSpawnsInCurrentWave(spawn.spawnType) < GetMaxSpawnsAllowedInCurrentWave(spawn));
}
public int GetMaxMinSpawnsAllowedCurrentInWave(PLESpawn spawn)
{
return
(Mathf.Min(spawn.MaxPerWave - GetNumberSpawnsInNextWave(spawn),
WorkingLevelData.NumSpawns(spawn.spawnType, CurrentWaveIndex)));
}
private int RemainingSpawnsInCurrentWave(PLESpawn spawn)
{
return(SpawnManager.RemainingSpawnsAllowedInCurrentWave(spawn));
}
private int GetRequiredKillCountInCurrentWave(PLESpawn spawn)
{
return(SpawnManager.GetRequiredKillCountInCurrentWave(spawn));
}
private int GetMaxMinSpawnsAllowedInCurrentWave(PLESpawn spawn)
{
return(SpawnManager.GetMaxMinSpawnsAllowedCurrentInWave(spawn));
}
