Question Why is this code decreasing my value in the Scriptable Object?

I cannot figure out why this code also decreases the value of the

value

variable in the inspector on my Scriptable object, and how to fix it?

Code (CSharp):

1. public int GetDaysRemaining()
2.     {
3.         int total = (int)myScriptableObject.value;
4.         int result = total - days;
5.         return result;
6.     }

 

Unless your compiler is very drunk, this code doesn't modify any variables. Your problem lies somewhere else. I suggest you set some breakpoints and monitor the value of

value

to see where it actually changes.

 

That's one way, yes. Though as so many people recently asked question why you would ever make variables private, that's the exact reason. You keep variables private to a class and that class is the only one that has access to it. So any change to the internal state of the class has to happen through methods or properties that the class itself provides. That way you can easily check inside those methods if, when and from where those methods are actually called. THAT's the main point of encapsulation. OOP is a programming paradigm where you restrict yourself from doing stupid things you can't remember two weeks (or 10 minutes) later.

 

This is the only place I reference it in the entire project. I'm 100% sure this is what caused it. When I started Unity today the same code didnt effect it anymore.

 

Those two sentences are incompatible. Code does not do random things depending on how it feels. So since the same code does not magically change the value now, it never has. So your 100% is actually 0%

This also is quite vague. What exactly did you observe? What was the original value and by how much did it decrease?

A simple approach to figure out who may actually read or write a certain value is to make the variable private, mark is with SerializeField and replace the original variable with a property. That way you can insert Debug.Logs into both, the getter and the setter and you get a complete stacktrace so you know who and from where someone may read or write values

Code (CSharp):

1.     [SerializeField]
2.     private float m_Value;
3.     public float value
4.     {
5.         get
6.         {
7.             //Debug.Log("Reading value: " + m_Value);
8.             return m_Value;
9.         }
10.         set
11.         {
12.             //Debug.Log("Set value from " +m_Value +" to "+ value);
13.             m_Value = value;
14.         }
15.     }

Just comment in the two Log lines and you can watch ANY change that may happen to the variable and you also see the old and the new value in each case.

 

Or just right click on your field and choose "Find All References" or (Shift+F12), VS will show you "who" is using/modifying the field.



Learning how to use your tools correctly (especially your IDE) will prevent you lot of headaches and time wasting.

Also as noted above, 99% of time your fields should be private (actually I never had a public field in my entire life). If you need to expose a value, use a (read-only) property instead.

 

Like I said, its only used in 1 place, and restarting unity fixed the issue. I know how to find references