/// <summary>
/// [DEV] removes all spawners from the level then adds new ones at every path that begins where no other path ends
/// </summary>
[Show][VisibleWhen("levelLoaded")] private void autoPlaceSpawners()
{
//destroy the existing spawners
foreach (GameObject go in GameObject.FindGameObjectsWithTag("EnemySpawner"))
{
Destroy(go);
}
spawnerObjects.Clear();
//clear the spawner list
data.spawners.Clear();
//for every path that starts where no other path ends...
foreach (PathSegment path in data.pathSegments.FindAll(s => !data.pathSegments.Exists(ss => s.startPos == ss.endPos)))
{
//... add a spawner to the list
SpawnerData newData = new SpawnerData();
newData.spawnVec = path.startPos;
data.spawners.Add(newData);
}
//create the spawner objects
foreach (SpawnerData sd in data.spawners)
{
GameObject s = (GameObject)GameObject.Instantiate(spawnerPrefab); //create spawner
s.SendMessage("SetData", sd); //provide its data
spawnerObjects.Add(s);
}
}
public void Save()
{
// SET objects to spawner.objects
List <GameObject> objects = spawner.objects;
// SET xmlContainer to new XMLContainer
xmlContainer = new XMLContainer();
// SET xmlContainer.data to new SpawnerData[objects.Count]
xmlContainer.data = new SpawnerData[objects.Count];
// FOR i = 0 to objects.Count
for (int i = 0; i < objects.Count; i++)
{
// SET data to new SpawnerData
SpawnerData data = new SpawnerData();
// SET item to objects[i]
GameObject item = objects[i];
// SET data's position to item's position
data.position = item.transform.position;
// SET data's rotation to item's rotation
data.rotation = item.transform.rotation;
// SET xmlContainer.data[i] to data
xmlContainer.data[i] = data;
}
// CALL SaveToPath(fullPath)
SaveToPath(fullPath);
}
// saves whatever data value is to Xml File
public void Save()
{
// Set data to new data
data = new XMLContainer();
// Set objects to objects in spawner
List <GameObject> objects = spawner.objects;
// Set data.spawners to new SpawnerData [objects.count]
data.spawners = new SpawnerData[objects.Count];
// For i= 0 to objects.count
for (int i = 0; i < objects.Count; i++)
{
// Set spawnerData to new SpawnerData
SpawnerData spawnerData = new SpawnerData();
// set item to objects [i]
GameObject item = objects[i];
// Set spawner's position to position
spawnerData.position = item.transform.position;
// Set spawner's rotation to rotation
spawnerData.rotation = item.transform.rotation;
// Set data.spawners[i] = spawnerData
data.spawners[i] = spawnerData;
}
// Call SaveToPath(fullPath)
SaveToPath(fullPath);
}
public void Initialize(SpawnerData spawnerData)
{
m_pointValue = spawnerData.PointValue;
// Set bullet pattern
enemyPathSteps = spawnerData.MovementPattern;
base.Initialize(spawnerData.StartingLocation, spawnerData.Health, spawnerData.Speed);
}
/// <summary>
/// Saves whatever data value is to XML file
/// </summary>
public void Save()
{
// SET data to new Data
data = new XMLContainer();
// SET objects to objects in spawner
List <GameObject> objects = spawner.objects;
// SET data to new SpawnerData[obejcts.count]
data.spawners = new SpawnerData[objects.Count];
// FOR i = 0 to objects.Count
for (int i = 0; i < objects.Count; i++)
{
// SET spawner to new Spawnerdata
SpawnerData spawnerData = new SpawnerData();
// SET item to objects[i]
GameObject item = objects[i];
// SET spawners position and rotation to item's
spawnerData.position = item.transform.position;
spawnerData.rotation = item.transform.rotation;
// SET data.spawners[i] = spawner;
data.spawners[i] = spawnerData;
}
// CALL SaveToPath(fullPath)
SaveToPath(fullPath);
}
/**
* Constructs a Wave from parameters list
*/
public Wave(uint id, string name, bool blocking, float timing, SpawnerData spawner)
{
WaveID = id;
WaveName = name;
WaveBlocking = blocking;
WaveTiming = timing;
WaveSpawner = spawner;
}
/**
* Copy constructor
*/
public Wave(Wave other)
{
WaveID = other.WaveID;
WaveName = other.WaveName;
WaveBlocking = other.WaveBlocking;
WaveTiming = other.WaveTiming;
WaveSpawner = other.WaveSpawner;
}
/**
* Default constructor
*/
public Wave()
{
WaveID = 0;
WaveName = "Unknown";
WaveBlocking = true;
WaveTiming = 0.0f;
WaveSpawner = null;
}
public void InstantiateSpawner(SpawnerData spawnerData, GameObject spawnerPrefab)
{
GameObject spawner = Instantiate(spawnerPrefab, spawnerData.position, Quaternion.Euler(0, 0, spawnerData.rotation));
spawner.transform.parent = transform;
ProjectileSpawner spawnerScript = spawner.GetComponent <ProjectileSpawner>();
spawner.name = "Spawner " + (currentLevelSpawnerList.Count + 1) + " layer " + spawnerScript.layerData.layerIndex;
spawnerScript.spawnerData = spawnerData;
currentLevelSpawnerList.Add(spawnerScript);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var compData = new SpawnerData()
{
CountX = CountX,
CountY = CountY,
//Simply map gameobject with entity
Prefab = conversionSystem.GetPrimaryEntity(prefab)
};
dstManager.AddComponentData(entity, compData);
}
public SpawnerData Copy()
{
SpawnerData clone = new SpawnerData();
clone.position = position;
clone.rotation = rotation;
clone.frequency = frequency;
clone.offsetInSeconds = offsetInSeconds;
clone.initForceFactor = initForceFactor;
clone.populate = populate;
return(clone);
}
SpawnParameters CalculateSpawnParameters(SpawnerData data)
{
var parameters = new SpawnParameters();
parameters.position = new Vector3(transform.position.x + Random.Range(-volumeSize.x / 2, volumeSize.x / 2),
transform.position.y + Random.Range(-volumeSize.y / 2, volumeSize.y / 2),
transform.position.z + Random.Range(-volumeSize.z / 2, volumeSize.z / 2));
parameters.rotation = Quaternion.Euler(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360));
parameters.scale = new Vector3(data.CalculateScale(), data.CalculateScale(), data.CalculateScale());
return(parameters);
}
public void Initialize(SpawnerData spawnerData)
{
spawnGroups = spawnerData.SpawnGroups;
groupsLevels = spawnerData.GroupsLevels;
groupCalls = spawnerData.GroupCalls;
countUnits = spawnerData.CountUnits;
spawnInterval = spawnerData.Interval;
spawnInsideInterval = spawnerData.InsideInterval;
interval = 0;
insideInterval = 0;
groupIndex = 0;
unitsSpawned = 0;
}
// Applies the saved data to the scene
void Apply()
{
// SET data to xmlContainer.data
SpawnerData[] data = xmlContainer.data;
// FOR i = 0 to data.Length
for (int i = 0; i < data.Length; i++)
{
// SET d to data[i]
SpawnerData d = data[i];
// CALL spawner.Spawn() and pass d.position, d.rotation
spawner.Spawn(d.position, d.rotation);
}
}
// Applies the save data to scene using Spawner
void Apply()
{
// Set spawners to data.spawners
SpawnerData[] spawners = data.spawners;
// For i = 0 to spawners.Length
for (int i = 0; i < spawners.Length; i++)
{
// Set data to spawners[i]
SpawnerData data = spawners[i];
// Call spawner.Spawn() and pass data.position, data.rotation
spawner.Spawn(data.position, data.rotation);
}
}
/// <summary>
/// Applies the saved data to the scene uUsing spawner)
/// /// </summary>
void Apply()
{
// SET spawners to data.spawners
XMLContainer spawners = new XMLContainer();
spawners = data;
// FOR i = 0 to spawners.Length
for (int i = 0; i < spawners.spawners.Length; i++)
{
// SET data to spawners[i]
SpawnerData d = spawners.spawners[i];
// CALL spawner.spawn() and pass daata.position, data.rotation
spawner.Spawn(d.position, d.rotation);
}
}
public bool Equals(SpawnerData other)
{
if (other == null)
{
return(false);
}
bool equal = true;
equal &= other.position == position;
equal &= other.rotation == rotation;
equal &= other.frequency == frequency;
equal &= other.offsetInSeconds == offsetInSeconds;
equal &= other.initForceFactor == initForceFactor;
equal &= other.populate == populate;
return(equal);
}
private void GetSpawnerData()
{
var spawners = GameObject.FindGameObjectsWithTag("EnemySpawner").ToList();
//Save all Spawner Data in List
foreach (var spawner in spawners)
{
var spawnPos = spawner.transform.position;
var data = new SpawnerData()
{
Pos = spawnPos,
Occupied = false
};
Destroy(spawner.gameObject);
_spawnerData.Add(data);
}
}
private void GetData()
{
var spawners = GameObject.FindGameObjectsWithTag("PowerupSpawner");
//Save all Spawner Data in List
foreach (var spawner in spawners)
{
var spawnPos = spawner.transform.position;
var data = new SpawnerData()
{
Pos = spawnPos
};
//Destroy the Game Objects associated with the Spawner Data to clean up
Destroy(spawner.gameObject);
_spawnerData.Add(data);
}
}
/**
*
*/
void OnGUI()
{
GUILayout.BeginArea(new Rect(10, 10, 230, 60));
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Spawner", GUILayout.Width(60)); GUILayout.Space(10);
spawnerData = EditorGUILayout.ObjectField(spawnerData, typeof(SpawnerData), false) as SpawnerData;
EditorGUILayout.EndHorizontal();
GUILayout.Space(20);
if (GUILayout.Button("Edit"))
{
StageEditorSpawnerEditionView.Init(spawnerData);
Close();
}
GUILayout.EndArea();
}
private void CheckForLevelEditing()
{
//If the spawner has been updated in the level scriptable object, reinit the spawner
if (!spawnerData.Equals(previousData))
{
previousData = spawnerData.Copy();
Init();
}
else //if the spawner has been updated in the scene, update the level scriptable object
{
if ((Vector2)transform.position != spawnerData.position)
{
spawnerData.position = transform.position;
previousData = spawnerData.Copy();
}
if (transform.eulerAngles.z != spawnerData.rotation)
{
spawnerData.rotation = transform.eulerAngles.z;
previousData = spawnerData.Copy();
}
}
}
/**
* Initializes the editor window
*/
public static void Init(SpawnerData data)
{
StageEditorSpawnerEditionView window = EditorWindow.GetWindow <StageEditorSpawnerEditionView>();
window.titleContent.text = "Spawner Editor";
window.maxSize = new Vector2(800, 500);
window.minSize = window.maxSize;
window.Show();
if (data != null)
{
window.spawnerData = data;
window.editorState = EditionState.Edition;
window.spawnerCountBuffer = data.SpawnerInfo.Count;
window.spawnerData.SortSpawnerInfo();
}
else
{
window.spawnerData = ScriptableObject.CreateInstance <SpawnerData>();
}
}
void GenerateObject(SpawnerData data)
{
var objectToSpawn = data.ObjectToSpawn();
var spnParams = CalculateSpawnParameters(data);
for (int i = 0; i < 100; i++)
{
if (CheckSpawnability(objectToSpawn, spnParams.position, spnParams.rotation, spnParams.scale))
{
Instantiate(objectToSpawn, spnParams.position, spnParams.rotation);
objectToSpawn.transform.parent = placeObjectsHere;
objectToSpawn.transform.localScale = spnParams.scale;
objectToSpawn.layer = gameObject.layer;
break;
}
else
{
objectToSpawn = data.ObjectToSpawn();
spnParams = CalculateSpawnParameters(data);
}
}
}
/**
* Initializes the wave handle
* @param wave The wave to process
* @param index The current index of the handle
*/
public void Init(Wave wave, int index)
{
paused = false;
this.wave = wave;
waveIndex = index;
waveState = WaveState.WaveRunning;
spawnerData = wave.WaveSpawner;
startEnemyCount = spawnerData.SpawnerInfo.Count;
if (spawnerData == null)
{
waveState = WaveState.WaveEnd;
return;
}
currentIndex = 0;
spawnerCoroutine = SpawnEnemies();
StartCoroutine(spawnerCoroutine);
debugSpawnCount = spawnerData.SpawnerSpawnCount;
enemyLeft = spawnerData.SpawnerInfo.Count;
parentTransform = GameObject.Find("Enemies").transform;
}
/**
* Saves the spawner data into the disk
* @param data The data to save
*/
public static void SaveAsset(SpawnerData data)
{
AssetDatabase.CreateAsset(data, "Assets/Resources/Databases/Spawners/" + data.SpawnerName + ".asset");
}
public void Populate(Gathering gatherer)
{
SpawnerResetTime sRT;
//Debug.Log(spawnerReset.Count);
if (spawnerReset.Count == 0)
{
SetResetDictionary();
}
if (spawnerReset.TryGetValue(gatherer.gameObject.name, out sRT))
{
if (gatherer.special && !GameObject.FindObjectOfType <ShrineManager>().endNature)
{
return;
}
if (sRT.numberOfDaysLeft > 0)
{
return;
}
else
{
SpawnerResetTime newTime = new SpawnerResetTime();
SpawnerData newData = new SpawnerData();
string newPlant = "";
/*do {
* int ran = Random.Range(0, rl.ingredients.Count);
* newPlant = plants[ran];
* } while (!rl.ingredients[newPlant].imagePath.StartsWith("Plants"));*/
float ran;
int dom;
if (gatherer.name.Contains("Forest"))
{
ran = Random.Range(0f, 1f);
if (ran < 0.4f)
{
dom = Random.Range(0, LowForestList.Count);
newPlant = LowForestList[dom];
}
else if (ran < 0.7f && ran > 0.3f)
{
dom = Random.Range(0, MidForestList.Count);
newPlant = MidForestList[dom];
}
else
{
dom = Random.Range(0, HighForestList.Count);
newPlant = HighForestList[dom];
}
//newPlant = ForestList[ran];
}
else if (gatherer.name.Contains("Meadow"))
{
ran = Random.Range(0f, 1f);
if (ran > 0.6f)
{
dom = Random.Range(0, HighMeadowList.Count);
newPlant = HighMeadowList[dom];
}
else //if (ran < 0.7 && ran > 0.3)
{
dom = Random.Range(0, MidMeadowList.Count);
newPlant = MidMeadowList[dom];
}
/*else
* {
* dom = Random.Range(0, LowMeadowList.Count);
* newPlant = LowMeadowList[dom];
* }
*/
//newPlant = MeadowList[ran];
}
else if (gatherer.name.Contains("Mountain"))
{
ran = Random.Range(0f, 1f);
if (ran > 0.4f)
{
dom = Random.Range(0, HighMountainList.Count);
newPlant = HighMountainList[dom];
}
else if (ran < 0.7f && ran > 0.3f)
{
dom = Random.Range(0, MidMountainList.Count);
newPlant = MidMountainList[dom];
}
else
{
dom = Random.Range(0, LowMountainList.Count);
newPlant = LowMountainList[dom];
}
//newPlant = MountainList[ran];
}
newData.spawnedItem = rl.ingredients[newPlant];
newData.hasSpawnedItem = true;
spawnerData.Add(gatherer.gameObject.name, newData);
spawnerReset.TryGetValue(gatherer.gameObject.name, out newTime);
newTime.numberOfDaysLeft = defaultResetTime;
spawnerReset[gatherer.gameObject.name] = newTime;
Sprite[] plantSprites = Resources.LoadAll <Sprite>("Plants/" + newData.spawnedItem.name);
gatherer.GetComponent <SpriteRenderer>().sprite = plantSprites[plantSprites.Length - 1];
}
}
else
{
StartCoroutine(Spawn());
}
}
public void Serialize(EB.BitStream bs)
{
bs.Serialize(ref _posX);
bs.Serialize(ref _posZ);
bs.Serialize(ref _selectedZone);
bs.Serialize(ref _interactionSetIndex);
bs.Serialize(ref _layoutName);
if (bs.isWriting)
{
int numTags = Tags.Count;
bs.Serialize(ref numTags);
foreach (string tag in Tags)
{
string t = tag;
bs.Serialize(ref t);
}
int numSpawners = Spawners.Count;
bs.Serialize(ref numSpawners);
foreach (SpawnerData spawner in Spawners)
{
spawner.Serialize(bs);
}
int numLootables = Lootables.Count;
bs.Serialize(ref numLootables);
foreach (LootableData lootable in Lootables)
{
lootable.Serialize(bs);
}
}
else
{
int numTags = 0;
bs.Serialize(ref numTags);
Tags = new List <string>();
for (int i = 0; i < numTags; i++)
{
string tag = string.Empty;
bs.Serialize(ref tag);
Tags.Add(tag);
}
int numSpawners = 0;
bs.Serialize(ref numSpawners);
Spawners = new List <SpawnerData>();
for (int i = 0; i < numSpawners; i++)
{
SpawnerData spawner = new SpawnerData();
spawner.Serialize(bs);
Spawners.Add(spawner);
}
int numLootables = 0;
bs.Serialize(ref numLootables);
Lootables = new List <LootableData>();
for (int i = 0; i < numLootables; i++)
{
LootableData lootable = new LootableData();
lootable.Serialize(bs);
Lootables.Add(lootable);
}
}
}
// Start is called before the first frame update
void Start()
{
projectiles = new List <GameObject>();
previousData = spawnerData.Copy();
Init();
}
protected override void OnUpdate()
{
List <SpawnerData> spawnerDatas = new List <SpawnerData>(10);
EntityManager.GetAllUniqueSharedComponentData(spawnerDatas);
int instanceCount = 0;
int length = spawnerDatas.Count;
for (int i = 0; i < length; ++i)
{
SpawnerData spawnerData = spawnerDatas[i];
SpawnerGroup.SetFilter(spawnerData);
EntityArray entities = SpawnerGroup.GetEntityArray();
instanceCount += entities.Length;
}
NativeArray <SpawnInstance> spawnInstances = new NativeArray <SpawnInstance>(instanceCount, Allocator.Temp);
{
int spawnIndex = 0;
for (int sharedIndex = 0; sharedIndex < length; ++sharedIndex)
{
SpawnerData spawnerData = spawnerDatas[sharedIndex];
SpawnerGroup.SetFilter(spawnerData);
EntityArray entities = SpawnerGroup.GetEntityArray();
for (int entityIndex = 0; entityIndex < entities.Length; entityIndex++)
{
SpawnInstance spawnInstance = new SpawnInstance();
spawnInstance.sourceEntity = entities[entityIndex];
spawnInstance.spawnerIndex = sharedIndex;
spawnInstances[spawnIndex] = spawnInstance;
spawnIndex++;
}
}
}
for (int spawnIndex = 0; spawnIndex < spawnInstances.Length; spawnIndex++)
{
int spawnerIndex = spawnInstances[spawnIndex].spawnerIndex;
SpawnerData spawnerData = spawnerDatas[spawnerIndex];
int count = spawnerData.Count;
var entities = new NativeArray <Entity>(count, Allocator.Temp);
GameObject prefab = spawnerData.Prefab;
Entity sourceEntity = spawnInstances[spawnIndex].sourceEntity;
float yOffset = spawnerData.yOffset;
EntityManager.Instantiate(prefab, entities);
float3 position = EntityManager.GetComponentData <Position>(sourceEntity).Value;
ParentSpawnerData parentData = new ParentSpawnerData();
parentData.Parent = sourceEntity;
for (int i = 0; i < count; i++)
{
Position positionComponent = new Position {
Value = position + new float3(0, yOffset, 0)
};
EntityManager.SetComponentData(entities[i], positionComponent);
EntityManager.AddSharedComponentData(entities[i], parentData);
}
EntityManager.GetComponentObject <Transform>(sourceEntity).GetComponent <SpawnerComponent>().enabled = false;
entities.Dispose();
}
spawnInstances.Dispose();
}
//sets data for this spawner
private void SetData(SpawnerData newData)
{
data = newData;
transform.localPosition = spawnPos;
paths = null; //clear cached path data
}
