private void OnPlaceableDealtDamage(Spawnable p)
{
if (p.target.state != Spawnable.States.Dead)
{
float newHealth = p.target.SufferDamage(p.damage);
}
}
/*
* Spawn a monster on the current map
*/
protected override void Spawn(Spawnable spawnable)
{
GameObject obj = spawnable.gameObject;
// if whithout position
if (obj.transform.position.Equals(Vector3.zero))
{
int nbrCell = (MeshMap.Instance.HeightMap * MeshMap.Instance.WidthMap);
Cell randomCell;
// Get a valid cell
do
{
randomCell = MeshMap.Instance.getCellFromId(Random.Range(0, nbrCell));
}while(randomCell.Content);
// Spawn
Vector2?randomPosition = MeshMap.Instance.getPositionFromCell(randomCell);
if (randomPosition.HasValue)
{
Debug.Log("Spawn monster : " + randomPosition);
obj.transform.position = new Vector3(randomPosition.Value.x, randomPosition.Value.y, -1.0f);
obj.name = this.prefabSpawnable.name;
obj.SetActive(true);
obj.GetComponent <Placable> ().PlaceObject();
}
}
else
{
// reload mob
obj.SetActive(true);
obj.transform.position = new Vector3(obj.transform.position.x - 0.5f, obj.transform.position.y - 0.5f, -1.0f);
obj.GetComponent <Placable> ().PlaceObject();
}
}
//These two functions are only used so different threads don't base on the same data and fs up
public Spawnable(Spawnable spawnable)
{
this._noiseMergeType = spawnable._noiseMergeType;
this._noiseSettingsData = spawnable._noiseSettingsData;
this._subSpawners = spawnable._subSpawners;
this._parentOnly = spawnable._parentOnly;
this._rotationAmount = spawnable._rotationAmount;
this._noiseStartPoint = spawnable._noiseStartPoint;
this._thickness = spawnable._thickness;
this._uniformSpreadAmount = spawnable._uniformSpreadAmount;
this._randomSpread = spawnable._randomSpread;
this._offsetAmount = spawnable._offsetAmount;
this._spawnFixedHeight = spawnable._spawnFixedHeight;
this._size = spawnable._size;
this._spacing = spawnable._spacing;
this._othersCanSpawnInside = spawnable._othersCanSpawnInside;
this._spawnDifferencial = spawnable._spawnDifferencial;
this._softMinAmount = spawnable._softMinAmount;
this._hardMinHeight = spawnable._hardMinHeight;
this._softMaxAmount = spawnable._softMaxAmount;
this._hardMaxHeight = spawnable._hardMaxHeight;
this._surfaceNormalAmount = spawnable._surfaceNormalAmount;
this._pointAlongNormalRandomness = spawnable._pointAlongNormalRandomness;
this._softMinSlope = spawnable._softMinSlope;
this._hardMinSlope = spawnable._hardMinSlope;
this._softMaxSlope = spawnable._softMaxSlope;
this._hardMaxSlope = spawnable._hardMaxSlope;
this._noise = spawnable._noise;
this._offsetNoise = spawnable._offsetNoise;
this._spreadNoise = spawnable._spreadNoise;
this._prefabs = spawnable._prefabs;
}
void Start()
{
boxCollider = GetComponent <BoxCollider2D>();
rend = GetComponent <Renderer>();
spawnable = GetComponent <Spawnable>();
smoke = GetComponent <ParticleSystem>();
}
void generateContainerIfNoneAvaliable(Spawnable spawnable)
{
if (spawnable.container == null)
{
spawnable.container = Instantiate(new GameObject("container"), transform);
}
}
private void SpawnObject(GameObject InSpawnPoint)
{
SpawnedObject = (GameObject)Instantiate(PrefabToSpawn, InSpawnPoint.transform.position, InSpawnPoint.transform.rotation);
SpawnedObject.transform.LookAt(Player.transform.position);
Spawnable ObjectComponent = SpawnedObject.GetComponent <Spawnable>();
if (ObjectComponent != null)
{
ObjectComponent.TimeLifespan = SpawnedObjectLifespan;
ObjectComponent.WasSpawned = true;
Spawnable.OnDestroyed += OnSpawnedObjectDestroyed;
ObjectComponent.SpawnedBy = this;
AudioSource Speaker = GetComponent <AudioSource>();
CubeObject CubeObj = SpawnedObject.GetComponent <CubeObject>();
if (CubeObj != null)
{
CubeObj.StunnerProgressBar = SpawnStunProgressBar();
}
else
{
Debug.Log("Spawned obj is not of type CubeObject.");
}
Speaker.Play();
}
else
{
Debug.Log("FATAL ERROR ! Spawned object dont have Spawnable component.");
}
IsSpawnedObjectAlive = true;
}
public void PlatformSelected()
{
Vector3 loc = Vector3.zero;
Quaternion rot = Quaternion.identity;
if (player.GetSpawnLocationAndRotation(out loc, out rot))
{
if (gameObject.activeSelf)
{
player.ToggleConstructionMenu();
}
Spawnable tSpawn = gameManager.GetBlueprint(SpawnableType.Decoration, "FloatingPlatform");
if (tSpawn.constructionEnergyRequired < player.playerEnergy.GetEnergy())
{
player.playerEnergy.SpendEnergy(tSpawn.constructionEnergyRequired);
loc.x = Mathf.Clamp(loc.x, -112.5f, 112.5f);
loc.z = Mathf.Clamp(loc.z, -112.5f, 112.5f);
gameManager.SpawnPlatform(tSpawn.pathStrings, loc);
//Now Spawn in other quadrants as well.
//Assuming loc to be ++, other position would be
Vector3 tLoc = new Vector3(-1 * loc.x, loc.y, loc.z);
gameManager.SpawnPlatform(tSpawn.pathStrings, tLoc);
tLoc = new Vector3(loc.x, loc.y, -1 * loc.z);
gameManager.SpawnPlatform(tSpawn.pathStrings, tLoc);
tLoc = new Vector3(-1 * loc.x, loc.y, -1 * loc.z);
gameManager.SpawnPlatform(tSpawn.pathStrings, tLoc);
}
else
{
player.playerUI.DisplayAlertMessage("You don't have enough energy");
}
}
}
GameObject NewSpawn(Spawnable spawnable, Vector3 position, Quaternion rotation)
{
GameObject newChild = Instantiate(spawnables[spawnable], position, rotation, transform);
newChild.name = spawnable.ToString();
return(newChild);
}
//private void OnDespawn(object sender, SpawnArgs e)
//{
// // Remove the spawnable and unregister from it
// activeList.Remove(e.Spawnable);
// e.Spawnable.OnDespawn -= OnDespawn;
//}
public bool GetNextEnemy(out Spawnable enemy)
{
if (spawnQueue.Count > 0) // Is there something to spawn?
{
string entry = spawnQueue.Dequeue();
// Fetch the spawn manager
Main main = Main.Instance;
ManagerStore managerStore = main.ManagerStore;
SpawnManager spawnManager = managerStore.Get <SpawnManager>();
// Try to spawn the enemy
if (spawnManager.Spawn(entry, out enemy))
{
// Register to the spawnables despawn
//enemy.OnDespawn += OnDespawn;
//activeList.Add(enemy);
return(true);
}
else // Enemy isn't valid
{
Debug.LogError("Wave manager unable to spawn " + entry + " because it's an invalid spawnable");
return(false);
}
}
else // Nothing to spawn
{
enemy = null;
return(false);
}
}
private void OnCurrentActiveCollectibleCollected(Spawnable s)
{
s.OnDeactivated -= OnCurrentActiveCollectibleCollected;
m_currentActiveCollectible = null;
m_spawnTimer = 0.0f;
m_spawnRate = 0.5f;
}
private void SpawnEnemy()
{
// Round robin spawning
if (_lanetospawn > 3)
{
_lanetospawn = 1;
}
if (_lastSpawned == Spawnable.Unicorn)
{
if (AIResponse.Spawn(Spawnable.Bunny, _lanetospawn))
{
_lastSpawned = Spawnable.Bunny;
}
}
else if (_lastSpawned == Spawnable.Bunny)
{
if (AIResponse.Spawn(Spawnable.Unicorn, _lanetospawn))
{
_lastSpawned = Spawnable.Unicorn;
}
}
_lanetospawn++;
}
public void PrepareWave()
{
//I need to figure out a place to spawn
//each type of spawnable as well as the quatity
//for each spawnable type.
EnemiesToSpawn = new List <Spawnable>();
Spawnables.ForEach(spawnable =>
{
for (var i = 0; i < spawnable.Quantity; i++)
{
var enemy = new Spawnable()
{
Enemy = spawnable.Enemy,
};
if (spawnable.SpawnPoint == null)
{
var spawnIndex = UnityEngine.Random.Range(0, SpawnPoints.Count);
enemy.SpawnPoint = SpawnPoints[spawnIndex];
}
else
{
enemy.SpawnPoint = spawnable.SpawnPoint;
}
EnemiesToSpawn.Add(enemy);
}
});
}
IEnumerator spawnCycle()
{
while (true)
{
/*float maxWeight = 0;
*
* for (int i = currentRound; i < rounds.Count; i++)
* {
* foreach (EnemySpawn j in rounds[i].enemies)
* {
* maxWeight += j.quantity;
* }
* }
*
* float chosenEnemy*/
foreach (EnemySpawn i in rounds[Random.Range(currentRound, rounds.Count)].enemies)
{
for (int j = 0; j < i.quantity; j++)
{
StartCoroutine(Spawnable.spawnEnemy(i.enemy));
}
}
yield return(new WaitForSeconds(Random.Range(minFrequency, maxFrequency + 0.01f)));
}
}
public void CreateExplosion(BombExplosionDTO bombExplosionDTO)
{
var explosionCoords = bombExplosionDTO.ExplosionCoords;
Spawnable explosion = new Spawnable(Bomb.ExplosionSprite, this.Position, this.Rotation)
{
ProjectileSprite = { Position = CalculateMapPos(explosionCoords[1].X, explosionCoords[0].Y) },
DespawnDrawableAfter = .5f
};
// set flame position to bomb
// despawn flame after
BombTriggers.Add(explosion);
for (int i = 0; i < directions.GetLength(0); i++)
{
int x = explosionCoords[1].X + directions[i][0];
int y = explosionCoords[0].Y + directions[i][1];
while (x != explosionCoords[i].X || y != explosionCoords[i].Y)
{
explosion = new Spawnable(Bomb.ExplosionSprite, this.Position, this.Rotation)
{
ProjectileSprite = { Position = CalculateMapPos(x, y) },
DespawnDrawableAfter = .5f
};
// set flame position to bomb
// despawn flame after
BombTriggers.Add(explosion);
x += directions[i][0];
y += directions[i][1];
}
}
}
public void UpdateSpawnables(float deltaTimeInSeconds)
{
// EXPLODE
for (int i = 0; i < Spawnables.Count; i++)
{
if (Spawnables[i] != null)
{
Spawnable p = Spawnables[i];
// Changing to Bomb.IgnitionDuration instead p.DespawnDrawableAfter
// removes Bomb decals too fast or slow (aka. local timescale instead global)
if (p.TimeSinceCreation > (float)(p.DespawnDrawableAfter / 1000))
{
// SPAWN EXPLOSIONS - just before bomb erases
Bomb.BombExplosionTimer.Restart(); // restart wait clock when placed
Spawnables.RemoveAt(i); // pop expired bomb
}
else
{
p.AddDeltaTime(deltaTimeInSeconds);
}
}
}
// Remove old explosions
UpdateBombColliders(deltaTimeInSeconds); // remove collider
}
// Start is called before the first frame update
void Start()
{
if (!hasIntroTransition)
{
foreach (EnemySpawn enemy in rounds[currentRound].enemies)
{
for (int i = 0; i < enemy.quantity; i++)
{
StartCoroutine(Spawnable.spawnEnemy(enemy.enemy));
}
}
rounds[currentRound].transition.startCheck();
if (rounds[currentRound].transition.hasTransitioned)
{
currentRound++;
}
}
else
{
introTransition.startCheck();
if (introTransition.hasTransitioned)
{
hasIntroTransition = false;
Start();
}
}
}
private void Update()
{
//press 1 to set active, 0 to reset TEMP
if (Input.GetKeyDown(KeyCode.Alpha1))
{
active = spawnable;
}
if (Input.GetKeyDown(KeyCode.Alpha0))
{
active = null;
DestroyGhost();
}
if (active != null)
{
//spawn and move ghost objects
if (!EventSystem.current.IsPointerOverGameObject())
{
GhostObject();
}
//left click to spawn objects
if (Input.GetMouseButtonDown(0))
{
if (!EventSystem.current.IsPointerOverGameObject())
{
InteractAtPoint();
}
}
}
}
/// <summary>
/// What should happen when the tune completes?
/// </summary>
/// <param name="crit">Was the tune played perfectly?</param>
public override void TuneComplete(bool crit)
{
base.TuneComplete(crit);
GameObject temp = (GameObject)GameObject.Instantiate(spawnObject, ownerTransform.position, ownerTransform.rotation);
if (attach)
{
temp.AddComponent <FollowTarget>();
temp.GetComponent <FollowTarget>().target = ownerTransform;
temp.GetComponent <FollowTarget>().offset = Vector3.zero;
}
Spawnable spawnable = temp.GetComponent <Spawnable>();
if (spawnable != null)
{
PlayerID ownerID = ownerTransform.GetComponent <BaseControl>().playerOwner;
spawnable.Owner(ownerID);
spawnable.Crit(crit);
if (ownerTransform.GetComponent <MinionTuneSpawn>() != null)
{
BaseBard bard = LevelManager.instance.GetBardFromID(ownerID);
spawnable.tune = bard.GetTuneFromName("Minion");
}
if (spawnable.tune == null)
{
spawnable.tune = this;
}
}
}
private SpawnEntry CreateStore(Spawnable prefab)
{
SpawnEntry spawnEntry = new SpawnEntry(prefab);
entries.Add(spawnEntry);
return(spawnEntry);
}
private void AddEnemyKill(Spawnable spawnable)
{
NavEnemy2D e = (NavEnemy2D)spawnable;
stats.enemiesKilled++;
switch (e.settings.enemyName)
{
case "melee":
stats.meleeEnemiesKilled++;
break;
case "ranged":
stats.rangedEnemiesKilled++;
break;
case "flying":
stats.flyingEnemiesKilled++;
break;
case "suicide":
stats.suicideEnemiesKilled++;
break;
case "tank":
stats.tankEnemiesKilled++;
break;
default:
throw new NotImplementedException("Enemy name: " + e.settings.enemyName + " not implemented!");
}
}
void OnTriggerEnter2D(Collider2D other)
{
Spawnable spawnable = other.GetComponent <Spawnable>();
switch (other.tag)
{
case "PowerUp":
spawnable.GetComponent <PowerUp>().OnHit();
GetComponent <PlayerControls>().IncreaseYDestination(nextY);
lambController.MoveDown();
soundPowerUp.Play();
break;
case "Obstacle":
Camera.main.GetComponent <CameraControl>().Shake(0.2f, 4, 100 * Time.deltaTime);
rb2d.AddForce(new Vector3(0, -200));
spawnable.GetComponent <Obstacle>().OnHit();
string colliderTag = other.tag;
lambController.MoveUp();
soundCrash.Play();
break;
case "lambs":
deadAnimation.SetActive(true);
break;
}
}
public void ReleaseGameObject(Spawnable _obj)
{
_obj.transform.SetParent(poolContainer);
_obj.transform.position = poolContainer.position;
_obj.gameObject.SetActive(false);
pool.Add(_obj);
}
/// <summary>
/// Spawns a creature // detailed instructions
/// </summary>
/// <param name="spawnable">the creature</param>
public bool Spawn(Spawnable creature, int lane)
{
LaneNode node = TournamentManager._instance.lanes[lane - 1].GetFirstLaneNode(logicBase);
IResponse response = new ActionResponse(creature == Spawnable.Bunny ? TournamentManager._instance.bunnyPrefab.GetComponent <CreatureBase> () : TournamentManager._instance.unicornPrefab.GetComponent <CreatureBase> (), lane, logicBase, ResponseActionType.Spawn, node);
/* fail the Spawn */
// LogStack.Log ("Tokens: " + tokens, LogLevel.Debug);
// LogStack.Log ("Node Creature Count: " + (node.activeCreature != null ? 1 : 0), LogLevel.System);
if (lane > TournamentManager._instance.lanes.Count || node.activeCreature != null || spawnNodesTaken.Contains(node))
{
// LogStack.Log ("Response | Spawn Failed Lane: " + lane, LogLevel.Stack);
return(false);
}
else
{
if (!SpendToken())
{
return(false);
}
// LogStack.Log ("Response | Spawn Success Lane: " + lane, LogLevel.Stack);
spawnNodesTaken.Add(node);
if (!ResponseChain.Contains(response))
{
ResponseChain.Add(response);
}
else
{
LogStack.Log("##### Duplicate Spawn Response", LogLevel.System);
RefundToken();
}
return(true);
}
}
private void OnTriggerEnter(Collider other)
{
if (other.CompareTag("Spawnable"))
{
Spawnable spawnable = other.GetComponent <Spawnable>();
spawnable.Spawn();
}
}
public void SetTarget(Spawnable target)
{
Collider targetCollider;
bool collExist = target.transform.TryGetComponent <Collider>(out targetCollider);
pointOnTarget = collExist ? RandomPointInCollider(targetCollider) : target.transform.position;
shootDirection = (pointOnTarget - transform.position).normalized;
}
public void CmdSpawnOnServer(int _spawnIndex, Vector3 _position, Quaternion _rotation, NetworkIdentity _owningPlayerID)
{
Spawnable spawningObj = SpawnablesList[_spawnIndex];
Spawnable spawningInstance = (Spawnable)Instantiate(spawningObj, _position, _rotation);
NetworkServer.Spawn(spawningInstance.gameObject);
//mCurrentSpawnableInstance = null;
}
private void Despawn(SpawnManager spawnManager, Spawnable instance)
{
// Store the manager for re-use
spawnManager.Store(instance);
// Move out of the scene
instance.transform.position = new Vector3(0, -100, 0);
}
void Awake()
{
playerCam = GameObject.FindGameObjectWithTag("MainCamera");
SpriteRenderer sprite = GetComponent <SpriteRenderer>();
sprite.flipX = Spawnable.SpriteFlip();
transform.SetParent(GameObject.FindGameObjectWithTag("Map").transform);
}
public void Remove(Spawnable spawnable)
{
listSpawners.ForEach(spawner => {
if (spawner.prefabSpawnable.GetType().Equals(spawnable.GetType()))
{
spawner.Remove(spawnable);
}
});
}
Spawnable AllocateGameObject()
{
Spawnable obj = pool[pool.Count - 1];
pool.RemoveAt(pool.Count - 1);
obj.transform.SetParent(null);
obj.gameObject.SetActive(true);
return(obj);
}
public void Spawn(Spawnable spawn)
{
spawnQueue.Enqueue(spawn);
}
protected virtual List<GameObject> getEntityList(Spawnable.Type type)
{
switch (type)
{
case Spawnable.Type.HERO:
return heroList;
case Spawnable.Type.PROJECTILE:
return projectileList;
case Spawnable.Type.PORTAL:
return portalList;
default:
return null;
}
}
bool GetSpawnableClean(BuildingBlock initialBlock, float playerRot, Spawnable currentSpawn, out Dictionary<string, object> data)
{
data = new Dictionary<string, object>();
posCleanData = new Dictionary<string, object>();
rotCleanData = new Dictionary<string, object>();
normedPos = GenerateGoodPos(initialBlock.transform.position, currentSpawn.transform.position, playerRot);
normedYRot = currentSpawn.transform.rotation.ToEulerAngles().y - playerRot;
data.Add("prefabname", currentSpawn.GetComponent<BaseNetworkable>().LookupPrefabName().ToString());
posCleanData.Add("x", normedPos.x);
posCleanData.Add("y", normedPos.y);
posCleanData.Add("z", normedPos.z);
data.Add("pos", posCleanData);
rotCleanData.Add("x", currentSpawn.transform.rotation.ToEulerAngles().x);
rotCleanData.Add("y", normedYRot);
rotCleanData.Add("z", currentSpawn.transform.rotation.ToEulerAngles().z);
data.Add("rot", rotCleanData);
return true;
}
public void OnGUI()
{
if (gardenCompleteStart != -1) {
return;
}
GUI.skin = skin;
int pos = 0;
int buttonSize = 40;
foreach(Spawnable s in GameConfig.instance.spawnables) {
if(GameDriver.instance.currentLevel.disabled.Contains(s.type)) {
continue;
}
string msg = "Plant " + s.type;
if (s.cost.seed == 1) {
msg += " (" + s.cost.seed + "seed)";
} else {
msg += " (" + s.cost.seed + "seeds)";
}
GUI.enabled = funds.canAfford(s.cost);
if(GUI.Button(new Rect(0, pos, 250, buttonSize), msg)) {
if(buying == s) {
buying = null;
ClearPlantableEffect();
} else {
buying = s;
AudioSource.PlayClipAtPoint(s.selected, Camera.main.transform.position);
SetPlantableEffect(s.type);
}
}
pos += buttonSize;
}
GUI.enabled = true;
GUI.Label(new Rect(Screen.width - 200, 0, 200, 100), "Seeds: " + funds.seed);
string target = "target: ";
if(GameDriver.instance.currentLevel != null) {
bool firstItem = true;
foreach(KeyValuePair<PlantType, int> pair in GameDriver.instance.currentLevel.target) {
if (firstItem) {
firstItem = false;
} else {
target += ", ";
}
target += pair.Value + " " + pair.Key;
}
GUI.Label(new Rect(0, Screen.height - 50, Screen.width, 50), target);
}
}
public void SpawnPlant(GameObject ground)
{
if (!funds.canAfford(buying.cost)) {
return;
}
if (!ground.GetComponent<Ground>().IsPlantable(buying.type)) {
return;
}
funds -= buying.cost;
Plant plant = (Instantiate(buying.prefab) as GameObject).GetComponent<Plant>();
plant.Attach(ground.GetComponent<Ground>());
GameDriver.instance.PlantSpawned(plant.type);
buying = null;
ClearPlantableEffect();
AudioSource.PlayClipAtPoint(plantAtached, Camera.main.transform.position);
}
public void Start()
{
if (GameDriver.instance.currentLevel == null) {
funds = new Currency(0, 0, 0);
} else {
funds = GameDriver.instance.currentLevel.startingFunds;
}
buying = null;
groundLayer = LayerMask.NameToLayer("Ground");
clickMask = 1 << groundLayer | 1 << LayerMask.NameToLayer("Pickup");
whiteout = transform.FindChild("Whiteout").renderer.material;
whiteout.color = new Color(1, 1, 1, 1);
levelStart = Time.time;
//grounds = Resources.FindObjectsOfTypeAll(typeof(Ground)) as GameObject[];
grounds = GameObject.FindGameObjectsWithTag("Ground");
}
public static GameObject Spawn(Spawnable.Type type, Vector3 position, Quaternion rotation)
{
string resourceString = Spawnable.GetResourceString(type);
UnityEngine.Object obj = Resources.Load(resourceString, typeof(GameObject));
GameObject gameObject = GameObject.Instantiate(obj, position, rotation) as GameObject;
ISpawnable spawnable = gameObject.GetComponent<ISpawnable>();
if (spawnable == null)
throw new System.Exception("Unable to register spawnable. No Spawnable component found.");
spawnable.spawnType = type;
GameControl.RegisterSpawnable(gameObject);
return gameObject;
}
public SpawnableComponent(Spawnable spawnable, SerializedVector3 v3, SerializedQuaternion q)
{
Prefab = spawnable.GetComponent<BaseNetworkable>().LookupPrefabName();
LocalPosition = v3;
LocalRotation = q;
}
override protected List<GameObject> getEntityList(Spawnable.Type type)
{
switch (type)
{
case Spawnable.Type.ENEMY_TURRET:
return turretList;
default:
return base.getEntityList(type);
}
}
public void RemoveComponent(Spawnable spawnable)
{
var v3 = new SerializedVector3(spawnable.transform.position - Origo.Position.ToVector3());
var q = new SerializedQuaternion(spawnable.transform.rotation);
var component = new SpawnableComponent(spawnable, v3, q);
if (SpawnableComponents.ContainsKey(component.ToString()))
{
SpawnableComponents.Remove(component.ToString());
}
}
public void AddComponent(Spawnable spawnable)
{
if (Origo == null)
{
Origo = new Origo(new SerializedVector3(spawnable.transform.position), new SerializedQuaternion(spawnable.transform.rotation));
}
var v3 = new SerializedVector3(spawnable.transform.position - Origo.Position.ToVector3());
var q = new SerializedQuaternion(spawnable.transform.rotation);
var component = new SpawnableComponent(spawnable, v3, q);
if (component == null)
{
Pluton.Logger.LogDebug("[StructureRecorder] Deployable component is null!");
return;
}
if (!SpawnableComponents.ContainsKey(component.ToString()))
{
SpawnableComponents.Add(component.ToString(), component);
}
else
{
SpawnableComponents[component.ToString()] = component;
}
}
