How to store functions in Scriptable Objects

Question

Hello! I recently tried to program a game and wanted to create weapons with different abilities rather than just stats. So while I was searching for answers, I came across this post, which answered how to add functions to scriptable objects. However, I am a little confused about the application. In my project, I have a simple scriptable object called WeaponHandler

 public class WeaponHandler : ScriptableObject
 {
     public string Name;
     public GameObject Object;
     public Sprite Icon;
     //animation
     
     public float Cooldown;
     public float AttackDamage;
     public int Ammo;
     public virtual void OnUse()
     {
         Debug.Log("customize this");
     }
     //on hit
     
 }

And In it, I created a scriptable object called "Katana" in the editor. I tried to mutate the OnUse function by making another class named Katana in the same file and mutating the function like this.

 class Katana : WeaponHandler
 {
     public override void OnUse()
     {
         Debug.Log("Katana");
     }
 }

However, when I call the function from the Katana object it writes "customize this". How would I actually store a custom function in a Scriptable Object?

Answer 1

So to put an end to this as my original post that you refer to was not clear enough. This is how it is intended to be used and this is how it works (tested).

 using UnityEngine;
 
 public class BaseObj : ScriptableObject
 {
     public virtual void OnUse()
     {
         Debug.Log("Base Obj");
     }
 }
 
 public class Derived : BaseObj
 {
     public override void OnUse()
     {
         Debug.Log("derived");
     }
 }
 
 public class testscript : MonoBehaviour
 {
     public BaseObj EditorAssignedScriptableObjectTest;
     public void Start()
     {
         var baseObj = new BaseObj();
         var derivedObj = new Derived();
         BaseObj baseDerivedObj = new Derived();
         baseObj.OnUse();
         derivedObj.OnUse();
         baseDerivedObj.OnUse();
         EditorAssignedScriptableObjectTest.OnUse();
     }
 }

In ScriptableTest.cs i added this class as well to show that this can be used by loading from resources as well:

 [CreateAssetMenu(fileName = "ScriptableTest", menuName = "ScriptableObjects/testObj", order = 1)]
 public class ScriptableTest : BaseObj
 {
     public string objName;
     public override void OnUse()
     {
         Debug.Log("derived name: " + objName);
     }
 }

Then rightclick in your resources, go to Create -> ScriptableObjects -> testObj

Set some name for the object. Mine looked like this:

alt text

Then you assign that to your testscript behaviour:

scriptable object

This will create the following 4 messages in the following order:

Base Obj
derived
derived
derived name: Whatever name you assigned in the obj you created

If this is not how you are using this then please update your question with some more details of how you apply this.

Answer 2

Answer by ssarfaty · Nov 25, 2021 at 09:21 AM

You could try marking your OnUse function as abstract instead of virtual. Abstract functions only have a definition but no implementation, so calling OnUse from the Katana class should print "Katana".

Add comment · Show 1 · Share

Captain_Pineapple · Nov 25, 2021 at 04:33 PM 0

Share

No. I do not know why this got upvoted. A non abstract class can not contain an abstract function. You'd have to make WeaponHandler abstract for this to work.

Answer 3

To answer your question you can add a method (a class function) to an object by declaring it like:

 // Method signature with return type
 AccessModifier ReturnType NameOfMethod(Param1Type param1Name, ...) 
 {
      // Do some stuff here
      return returnTypeInstance;
 }
 
 e.g.
 
 public string GetName(string firstName, string surname)
 {
     return $"{firstName} {surname}";
 }
 
 // Or a method without a return type would use a void return type and would not need to invoke the statement
 
 public void DoSomething(string value)
 {
     // Do something here
 }

You can also use delegates/ lamdas to store functions into variables by declaring them using the Action or Func types Funcs having a return value and Actions being functions without.

That said for this I would probably learn about interfaces (in the loose sense either interfaces or abstract classes) and use a strategy pattern combined with composition i.e. keep the scriptable objects just as lean data only POCOs and then add an instance or collection of them as a member on another class and do all the weapon behaviour logic on that instead:

https://www.youtube.com/watch?v=v9ejT8FO-7I

Answer 4

Answer by logicandchaos · Nov 25, 2021 at 10:43 AM

You have things mixed up, the 1st script you create a scriptable object and then you say you make an instance of it called katana, but then you make a new katana script that inherits from WeaponHandler, but your scriptable object instance is still a WeaponHandler not a katana.

To use scriptable object you need to make the the instance of katana script not WeaponHandler script.

Add comment · Show 1 · Share

sacredgeometry · Nov 25, 2021 at 01:13 PM 0

Share

Where are they instantiating anything?

How to store functions in Scriptable Objects

4 Replies

Your answer

Follow this Question

Related Questions