Fenikkel · July 9, 2025 07:58 · Mar 21, 2025 · Mar 18, 2025 · Mar 18, 2025 · Mar 18, 2025
diff --git a/info.md → !nfo.md b/info.md → !nfo.md
diff --git a/info.md b/info.md
@@ -1,7 +1,7 @@
 # Factory pattern for Unity's prefabs
 
 <p align="center">
-        <img src="https://gist.github.com/user-attachments/assets/c0776d11-d8b2-4633-bcfd-f4eefca38fd7.webm" alt="Factory example">   
+        <img src="https://gist.github.com/user-attachments/assets/8541f9eb-1026-4778-8d49-d8f7b913eb97" alt="Factory example">   
 </p>
 
 &nbsp;

diff --git a/info.md b/info.md
@@ -1,5 +1,9 @@
 # Factory pattern for Unity's prefabs
 
+<p align="center">
+        <img src="https://gist.github.com/user-attachments/assets/c0776d11-d8b2-4633-bcfd-f4eefca38fd7.webm" alt="Factory example">   
+</p>
+
 &nbsp;
 ## Notes
 Simple tu use and foolproof. It uses abstraction to make it almost invisible on your code and easy to reuse it.

diff --git a/info.md b/info.md
@@ -54,21 +54,18 @@ public class FactoryManager : MonoBehaviour
 {
     [SerializeField] FactoryA _FactoryA;
     [SerializeField] FactoryB _FactoryB;
-    [SerializeField] FactoryC _FactoryC;
+    // More factories...
 
     private void Update()
     {
         if (Input.GetKeyDown(KeyCode.Q))
         {
             ProductA productA = (ProductA)_FactoryA.CreateProduct();
         }
-        else if (Input.GetKeyDown(KeyCode.W))
-        {
-            PrefabProduct productB = _FactoryB.CreateProduct(Vector3.left * 2, Quaternion.identity);
-        }
-        else if (Input.GetKeyDown(KeyCode.E))
+
+        if (Input.GetKeyDown(KeyCode.W))
         {
-            _FactoryC.CreateProduct(Vector3.right * 2, Quaternion.identity);
+            PrefabProduct productB = _FactoryB.CreateProduct(Vector3.up, Quaternion.identity);
         }
     }
 }

diff --git a/info.md b/info.md
@@ -80,3 +80,13 @@ public class FactoryManager : MonoBehaviour
         <img src="https://gist.github.com/user-attachments/assets/d9bcee6b-2a25-4a3a-9c85-b3424983753c" alt="Factory manager example">
 </p>
 
+&nbsp;
+## Compatibility
+- Any Unity version
+- Any pipeline (Build-in, URP, HDRP, etc)
+
+&nbsp;
+## Support
+⭐ Star if you like it  
+❤️️ Follow me for more
+
diff --git a/info.md b/info.md
@@ -60,11 +60,11 @@ public class FactoryManager : MonoBehaviour
     {
         if (Input.GetKeyDown(KeyCode.Q))
         {
-            _FactoryA.CreateProduct();
+            ProductA productA = (ProductA)_FactoryA.CreateProduct();
         }
         else if (Input.GetKeyDown(KeyCode.W))
         {
-            _FactoryB.CreateProduct(Vector3.left * 2, Quaternion.identity);
+            PrefabProduct productB = _FactoryB.CreateProduct(Vector3.left * 2, Quaternion.identity);
         }
         else if (Input.GetKeyDown(KeyCode.E))
         {
@@ -73,3 +73,10 @@ public class FactoryManager : MonoBehaviour
     }
 }
 ```
+
+7. Create a GameObject, attach your factory manager and assign your factory controllers:
+
+<p align="center">
+        <img src="https://gist.github.com/user-attachments/assets/d9bcee6b-2a25-4a3a-9c85-b3424983753c" alt="Factory manager example">
+</p>
+
diff --git a/info.md b/info.md
@@ -46,3 +46,30 @@ public class FactoryA : PrefabFactory<ProductA>
         <img src="https://gist.github.com/user-attachments/assets/bf0de962-e187-4de5-8002-472c70632bb9" alt="Factory controller example">
 </p>
 
+5. Repeat previous steps for each product
+
+6. Create a manager to control all your factories:
+```csharp
+public class FactoryManager : MonoBehaviour
+{
+    [SerializeField] FactoryA _FactoryA;
+    [SerializeField] FactoryB _FactoryB;
+    [SerializeField] FactoryC _FactoryC;
+
+    private void Update()
+    {
+        if (Input.GetKeyDown(KeyCode.Q))
+        {
+            _FactoryA.CreateProduct();
+        }
+        else if (Input.GetKeyDown(KeyCode.W))
+        {
+            _FactoryB.CreateProduct(Vector3.left * 2, Quaternion.identity);
+        }
+        else if (Input.GetKeyDown(KeyCode.E))
+        {
+            _FactoryC.CreateProduct(Vector3.right * 2, Quaternion.identity);
+        }
+    }
+}
+```
diff --git a/info.md b/info.md
@@ -39,4 +39,10 @@ public class FactoryA : PrefabFactory<ProductA>
         return newProduct;
     }
 }
-```
+```
+
+4. Create a GameObject, attach your factory controller and assign your prefab with the product controller to the variable `Product Prefab`:
+<p align="center">
+        <img src="https://gist.github.com/user-attachments/assets/bf0de962-e187-4de5-8002-472c70632bb9" alt="Factory controller example">
+</p>
+
diff --git a/info.md b/info.md
@@ -7,11 +7,12 @@ Simple tu use and foolproof. It uses abstraction to make it almost invisible on
 &nbsp;
 ## Usage
 
-1. Inherid PrefabProduct on your prefab controller class:
+1. Inherid `PrefabProduct` on your product controller class:
 ```csharp
-    public class PrefabControllerA : PrefabProduct
+    public class ProductA : PrefabProduct
     {
         public override void Initialize()
+
         {
             Debug.Log($"Unique initialization for <b>{this.GetType()}<b>");
         }
@@ -20,8 +21,22 @@ Simple tu use and foolproof. It uses abstraction to make it almost invisible on
     }
 ```
 
-2. Create a prefab for the product:
+2. Create a prefab for the product and attach your product controller:
 <p align="center">
+        <img src="https://gist.github.com/user-attachments/assets/9af55658-6d1a-48eb-95b9-419991df02b4" alt="Prefab example">
+</p>
+
+3. Inherid `PrefabFactory` with the desired type of product on your factory controller class:
+```csharp
+public class FactoryA : PrefabFactory<ProductA>
+{
+    public override PrefabProduct CreateProduct(Vector3 position = new Vector3(), Quaternion rotation = new Quaternion())
+    {
+        PrefabProduct newProduct = base.CreateProduct(position, rotation);
+
+        Debug.Log($"Unique behavior for <b>{this.GetType()}</b> while creating <b>{newProduct.GetType()}</b>");
 
-        <img src="" alt="Prefab example">
-</p>
+        return newProduct;
+    }
+}
+```
diff --git a/PrefabFactory.cs b/PrefabFactory.cs
@@ -0,0 +1,18 @@
+using UnityEngine;
+
+public abstract class PrefabFactory<T> : MonoBehaviour where T : Component
+{
+    [SerializeField]
+    protected T _ProductPrefab;
+
+    public virtual PrefabProduct CreateProduct(Vector3 position = new Vector3(), Quaternion rotation = new Quaternion()) 
+    {
+        GameObject instance = Instantiate(_ProductPrefab.gameObject, position, rotation);
+
+        PrefabProduct newProduct = instance.GetComponent<PrefabProduct>();
+
+        newProduct.Initialize();
+
+        return newProduct;
+    }
+}
diff --git a/PrefabProduct.cs b/PrefabProduct.cs
@@ -0,0 +1,17 @@
+using UnityEngine;
+
+public abstract class PrefabProduct : MonoBehaviour
+{
+    public abstract void Initialize();
+
+    /*
+        Add more mandatory methods:
+            - Destroy
+            - Select
+            - Move
+            - Damage
+            ...
+
+        (PrefabProduct works like an interface)
+     */
+}
diff --git a/info.md b/info.md
@@ -0,0 +1,27 @@
+# Factory pattern for Unity's prefabs
+
+&nbsp;
+## Notes
+Simple tu use and foolproof. It uses abstraction to make it almost invisible on your code and easy to reuse it.
+
+&nbsp;
+## Usage
+
+1. Inherid PrefabProduct on your prefab controller class:
+```csharp
+    public class PrefabControllerA : PrefabProduct
+    {
+        public override void Initialize()
+        {
+            Debug.Log($"Unique initialization for <b>{this.GetType()}<b>");
+        }
+
+        // Add prefab control functions here
+    }
+```
+
+2. Create a prefab for the product:
+<p align="center">
+
+        <img src="" alt="Prefab example">
+</p>
No results found