Better storage solution

I have a gameobject in my scene called 'Storage' which holds 5 scripts:

1. Tile Storage
2. Item Storage
3. Agent Storage
4. Attack Storage
5. LayerMask Storage

Basically these scripts hold variables that i want to access by many different scripts but don't want to manually input into all those different scripts.

For example, instead of manually assigning a LayerMask everytime, i have assigned a bunch of different layermasks to my storage script and retrieve them from there. Example:

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4.  
5. public class LayerMaskStorage : MonoBehaviour
6. {
7.     public static LayerMaskStorage instance;
8.  
9.     public LayerMask agents;
10.     public LayerMask groundPlayerAlly;
11.     public LayerMask playerAllyMask;
12.     public LayerMask enemyMask;
13.     public LayerMask enemyBlockMask;
14.     public LayerMask ground;
15.     void Awake(){
16.         instance = this;
17.     }
18. }
19.  

Code (CSharp):

1. LayerMaskStorage.instance.agents;

An example of my agent storage, which stores the different enemy prefabs:

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4.  
5. public class AgentStorage : MonoBehaviour
6. {
7.     public static AgentStorage instance;
8.     [HideInInspector]
9.     public List <GameObject> enemies = new List <GameObject>();
10.     [HideInInspector]
11.     public List <GameObject> enemiesSurface = new List <GameObject>();
12.     public List<GameObject> launchMenuEnemies = new List<GameObject>();
13.     public List<GameObject> caveEnemies = new List<GameObject>();  
14.     public GameObject Bat;
15.     public GameObject Bird;
16.     public GameObject Ghost;
17.     public GameObject Golem;
18.     public GameObject Imp;
19.     public GameObject Slime;
20.     public GameObject Slime2;
21.     public GameObject Slime3;
22.     public GameObject Zombie;
23.     public GameObject ZombieMiner;
24.     public GameObject CircleEnemy;
25.     public GameObject Spider;
26.     public GameObject BoulderEnemy;
27.  
28.     // Bosses
29.  
30.     public GameObject WormBoss;
31.     public GameObject SquidBoss;
32.     public List <GameObject> bosses = new List <GameObject>();
33.     void Awake(){
34.         instance = this;
35.         addEnemiesToList();
36.         addEnemiesToListSurface();
37.         addBossesToList();
38.         addLaunchMenuEnemies();
39.         addCaveEnemies();
40.     }
41.  
42.     void addCaveEnemies(){
43.         caveEnemies.Add(Bat);
44.         caveEnemies.Add(Spider);
45.     }
46.  
47.     void addLaunchMenuEnemies(){
48.         launchMenuEnemies.Add(Zombie);
49.         launchMenuEnemies.Add(Golem);
50.         launchMenuEnemies.Add(Slime);
51.     }
52.  
53.     void addBossesToList(){
54.         bosses.Add(WormBoss);
55.         bosses.Add(SquidBoss);
56.     }
57.  
58.     void addEnemiesToList(){
59.         enemies.Add(Bat);
60.         enemies.Add(Bird);
61.         enemies.Add(Ghost);
62.         enemies.Add(Golem);
63.         enemies.Add(Imp);
64.         enemies.Add(Slime);
65.         enemies.Add(Slime2);
66.         enemies.Add(Slime3);
67.         enemies.Add(Zombie);
68.         enemies.Add(ZombieMiner);
69.         enemies.Add(CircleEnemy);
70.     }
71.     void addEnemiesToListSurface(){
72.  
73.         enemiesSurface.Add(Ghost);
74.         enemiesSurface.Add(Golem);
75.         enemiesSurface.Add(Imp);
76.         enemiesSurface.Add(Slime);
77.         enemiesSurface.Add(Slime2);
78.         enemiesSurface.Add(Slime3);
79.         enemiesSurface.Add(Zombie);
80.         enemiesSurface.Add(ZombieMiner);
81.  
82.     }
83. }
84.  

Scriptableobject storage:

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4.  
5. public class ItemStorage : MonoBehaviour
6. {
7.     public static ItemStorage instance;
8.     // public List<Equipment> items;
9.     public Weapon[] weapons;
10.     public Equipment[] items;
11.     public Ability[] abilities;
12.     public GameObject[] weaponPrefabs;
13.     public Attack[] attacks;
14.  
15.     void Awake(){
16.         instance = this;
17.         items = (Equipment[]) Resources.FindObjectsOfTypeAll(typeof(Equipment));
18.         weapons = (Weapon[]) Resources.FindObjectsOfTypeAll(typeof(Weapon));
19.         abilities = (Ability[]) Resources.FindObjectsOfTypeAll(typeof(Ability));
20.         attacks = (Attack[]) Resources.FindObjectsOfTypeAll(typeof(Attack));
21.         weaponPrefabs = Resources.LoadAll<GameObject>("PickupItems/Weapons");
22.  
23.         foreach (var ability in abilities)
24.         {
25.             ability.offCD = true;
26.         }
27.     }
28.  
29.     public Equipment[] getItems(){
30.         return items;
31.     }
32. }
33.  

Every time my game runs all the storage items are added in. Is this bad practice? Should i be storing prefabs, scriptableobjects etc somehow else?

 

Well, to me the name is slightly misleading, as (again, to me) storage implies persistence. You are simply providing a kind of directory service or centralized accessor to scene components. I don't think that there's much to worry about this approach. Make sure that all the objects you reference need to be loaded at the start of the scene if you are targeting restricted devices (mobiles), but on the other hand, your scripts can be used to make sure all assets are in-memory at the start of the Scene as an additional benefit.