Adding "FloatArray" variable

mchourdakis · October 31

The idea is to allow multiple checks without many variables.
E.g. an action is taken when a book is taken and a page read. You have to have 2 variables and two actions to check both.
Instead you can have a float[2]. I checked and modified gvar.cs to include a "FloatArray" (and enum.cs) with the help of Claude.
From actions, you can now a) check a specific index of that array, therefore you can group related actions only to one variable and b) check all values of the array -> instant result when all the actions must be e.g. 1 to proceed.

Generally, limiting the number of variables needed if the data to be managed is "related" is a good idea.

I'm following this post with all the required changes in the cs files.

mchourdakis · October 31

Enum.cs VariableType

public enum VariableType { Boolean, Integer, String, Float, PopUp, Vector3, GameObject, UnityObject, FloatArray };

mchourdakis · October 31

GVar.gs

Property
[SerializeField] protected float[] floatArrayVal = new float[0];
In all constructors
floatArrayVal = new float[0];
Copy constructor
floatArrayVal = (assetVar.floatArrayVal != null) ? (float[]) assetVar.floatArrayVal.Clone () : new float[0];
GetValue
case VariableType.FloatArray: return "[" + string.Join (", ", System.Array.ConvertAll (FloatArrayValue, f => f.ToString ())) + "]";
CopyFromValue
case VariableType.FloatArray: { FloatArrayValue = (oldVar.floatArrayVal != null) ? (float[]) oldVar.floatArrayVal.Clone () : new float[0]; break; }

ShowGUI

        case VariableType.FloatArray:
            {
                if (floatArrayVal == null) floatArrayVal = new float[0];

                int newSize = Mathf.Max (0, CustomGUILayout.IntField ("Size:", floatArrayVal.Length, apiPrefix + ".FloatArrayLength", "The number of elements"));
                if (newSize != floatArrayVal.Length)
                {
                    System.Array.Resize (ref floatArrayVal, newSize);
                }

                for (int i = 0; i < floatArrayVal.Length; i++)
                {
                    floatArrayVal[i] = CustomGUILayout.FloatField ("Element " + i + ":", floatArrayVal[i], apiPrefix + ".FloatArrayValue[" + i + "]", helpText);
                }
                break;
            }

mchourdakis · October 31

GVar.gs helper

        /** Its values, if a FloatArray. */
        public float[] FloatArrayValue
        {
            get
            {
                if (floatArrayVal == null) floatArrayVal = new float[0];
                return floatArrayVal;
            }
            set
            {
                floatArrayVal = (value != null) ? value : new float[0];

                if (KickStarter.eventManager)
                {
                    KickStarter.eventManager.Call_OnVariableChange (this);
                }
            }
        }


        /** The number of elements, if a FloatArray. */
        public int FloatArrayLength
        {
            get
            {
                return FloatArrayValue.Length;
            }
        }


        /**
         * <summary>Gets the value at a given index, if a FloatArray</summary>
         * <param name = "index">The element index</param>
         * <param name = "value">The element's value, or 0 if the index is out of range</param>
         * <returns>True if the index was valid</returns>
         */
        public bool TryGetFloatArrayElement (int index, out float value)
        {
            float[] array = FloatArrayValue;
            if (index >= 0 && index < array.Length)
            {
                value = array[index];
                return true;
            }
            value = 0f;
            return false;
        }


        /**
         * <summary>Sets the value at a given index, if a FloatArray. The array is enlarged if the index is beyond its end.</summary>
         * <param name = "index">The element index</param>
         * <param name = "value">The new value</param>
         */
        public void SetFloatArrayElement (int index, float value)
        {
            if (index < 0) return;

            if (index >= FloatArrayValue.Length)
            {
                System.Array.Resize (ref floatArrayVal, index + 1);
            }

            float originalValue = floatArrayVal[index];
            floatArrayVal[index] = value;

            if (!Mathf.Approximately (originalValue, value) && KickStarter.eventManager)
            {
                KickStarter.eventManager.Call_OnVariableChange (this);
            }
        }

mchourdakis · October 31

SaveSystem.cs - CreateVariablesData

                        case VariableType.FloatArray:
                            {
                                float[] floatArray = _var.FloatArrayValue;
                                for (int i = 0; i < floatArray.Length; i++)
                                {
                                    if (i > 0) variablesString.Append (",");
                                    variablesString.Append (floatArray[i].ToString (System.Globalization.CultureInfo.InvariantCulture));
                                }
                                break;
                            }

UnloadVariablesData

                            case VariableType.FloatArray:
                                {
                                    float[] _values = new float[0];
                                    if (chunkData.Length > 1 && !string.IsNullOrEmpty (chunkData[1]))
                                    {
                                        string[] valuesArray = chunkData[1].Split (","[0]);
                                        _values = new float[valuesArray.Length];
                                        for (int i = 0; i < valuesArray.Length; i++)
                                        {
                                            float.TryParse (valuesArray[i], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _values[i]);
                                        }
                                    }
                                    _var.FloatArrayValue = _values;
                                    break;
                                }

mchourdakis · October 31

ActionVarSet.cs

Properties

        public SetVarMethodFloatArray setVarMethodFloatArray = SetVarMethodFloatArray.SetValue;
        public enum SetVarMethodFloatArray { SetValue, IncreaseByValue, SetAllElements };
        public int arrayIndex = 0;
        public int arrayIndexParameterID = -1;

AssignValues

arrayIndex = AssignInteger (parameters, arrayIndexParameterID, arrayIndex);

SetVariable

                case VariableType.FloatArray:
                    {
                        if (setVarMethodFloatArray == SetVarMethodFloatArray.SetAllElements)
                        {
                            float[] newArray = new float[var.FloatArrayLength];
                            for (int i = 0; i < newArray.Length; i++)
                            {
                                newArray[i] = floatValue;
                            }
                            var.FloatArrayValue = newArray;
                            break;
                        }

                        float currentValue;
                        if (!var.TryGetFloatArrayElement (arrayIndex, out currentValue))
                        {
                            LogWarning ("Cannot set index " + arrayIndex + " of FloatArray variable '" + var.label + "' - index is out of range (size = " + var.FloatArrayLength + ")");
                            break;
                        }

                        var.SetFloatArrayElement (arrayIndex, (setVarMethodFloatArray == SetVarMethodFloatArray.IncreaseByValue) ? currentValue + floatValue : floatValue);
                        break;
                    }

ShowVarGUI

                case VariableType.FloatArray:
                    setVarMethodFloatArray = (SetVarMethodFloatArray) EditorGUILayout.EnumPopup ("Method:", setVarMethodFloatArray);

                    if (setVarMethodFloatArray != SetVarMethodFloatArray.SetAllElements)
                    {
                        IntField ("Index:", ref arrayIndex, parameters, ref arrayIndexParameterID);
                        if (arrayIndexParameterID < 0 && arrayIndex < 0)
                        {
                            arrayIndex = 0;
                        }
                    }

                    label += (setVarMethodFloatArray == SetVarMethodFloatArray.IncreaseByValue) ? "+=" : "=";
                    FloatField (label, ref floatValue, parameters, ref setParameterID);
                    break;

SetLabel

                else if (variable.type == VariableType.FloatArray)
                {
                    switch (setVarMethodFloatArray)
                    {
                        case SetVarMethodFloatArray.SetValue:
                            labelAdd += "[" + arrayIndex + "] = " + floatValue;
                            break;

                        case SetVarMethodFloatArray.IncreaseByValue:
                            labelAdd += "[" + arrayIndex + "] += " + floatValue;
                            break;

                        case SetVarMethodFloatArray.SetAllElements:
                            labelAdd += " (all) = " + floatValue;
                            break;
                    }
                }

mchourdakis · October 31

ActionVarCheck.cs

Properties

        public enum FloatArrayCheckMode { AtIndex, AllElements };
        public FloatArrayCheckMode floatArrayCheckMode = FloatArrayCheckMode.AtIndex;
        public int arrayIndex = 0;
        public int arrayIndexParameterID = -1;

AssignValues

            arrayIndex = AssignInteger (parameters, arrayIndexParameterID, arrayIndex);

CheckCondition

            else if (_var.type == VariableType.FloatArray)
            {
                if (floatArrayCheckMode == FloatArrayCheckMode.AtIndex)
                {
                    return CheckFloatArrayElement (_var, _compareVar, arrayIndex);
                }

                if (_var.FloatArrayLength == 0)
                {
                    return false;
                }

                for (int i = 0; i < _var.FloatArrayLength; i++)
                {
                    if (!CheckFloatArrayElement (_var, _compareVar, i))
                    {
                        return false;
                    }
                }
                return true;
            }

Helper to add

        protected bool CheckFloatArrayElement (GVar _var, GVar _compareVar, int index)
        {
            float fieldValue;
            if (!_var.TryGetFloatArrayElement (index, out fieldValue))
            {
                LogWarning ("Cannot check index " + index + " of FloatArray variable '" + _var.label + "' - index is out of range (size = " + _var.FloatArrayLength + ")");
                return false;
            }

            float compareValue = floatValue;
            if (_compareVar != null && !_compareVar.TryGetFloatArrayElement (index, out compareValue))
            {
                return false;
            }

            switch (intCondition)
            {
                case IntCondition.EqualTo:
                    return Mathf.Approximately (fieldValue, compareValue);

                case IntCondition.NotEqualTo:
                    return !Mathf.Approximately (fieldValue, compareValue);

                case IntCondition.LessThan:
                    return (fieldValue < compareValue);

                case IntCondition.MoreThan:
                    return (fieldValue > compareValue);

                default:
                    return false;
            }
        }

ShowVarGUI

                case VariableType.FloatArray:
                    floatArrayCheckMode = (FloatArrayCheckMode) EditorGUILayout.EnumPopup ("Check:", floatArrayCheckMode);
                    if (floatArrayCheckMode == FloatArrayCheckMode.AtIndex)
                    {
                        IntField ("Index:", ref arrayIndex, parameters, ref arrayIndexParameterID);
                        if (arrayIndexParameterID < 0 && arrayIndex < 0)
                        {
                            arrayIndex = 0;
                        }
                    }
                    else
                    {
                        EditorGUILayout.HelpBox ("True only if every element satisfies the condition (and the array is not empty).", MessageType.Info);
                    }

                    intCondition = (IntCondition) EditorGUILayout.EnumPopup ("Condition:", intCondition);
                    if (getVarMethod == GetVarMethod.EnteredValue)
                    {
                        FloatField ("Float:", ref floatValue, parameters, ref checkParameterID);
                    }
                    break;

GetLabelString:

                            case VariableType.FloatArray:
                                labelAdd += ((floatArrayCheckMode == FloatArrayCheckMode.AtIndex) ? "[" + arrayIndex + "] " : " (all) ") + intCondition.ToString () + " " + floatValue.ToString ();
                                break;

mchourdakis · October 31

And a final AC action to check the float array either by index or ALL parameters

https://pastebin.com/tNJSd7QT

mchourdakis · October 31

A fix in SaveSystem to cope for expanded arrays after saves.

                            case VariableType.FloatArray:
                                {
                                    // Keep the size defined in the inspector - only restore values that fit within it
                                    float[] _values = (float[])_var.FloatArrayValue.Clone();

                                    if (chunkData.Length > 1 && !string.IsNullOrEmpty(chunkData[1]))
                                    {
                                        string[] valuesArray = chunkData[1].Split(","[0]);
                                        int numToRestore = Mathf.Min(valuesArray.Length, _values.Length);

                                        for (int i = 0; i < numToRestore; i++)
                                        {
                                            float parsedValue;
                                            if (float.TryParse(valuesArray[i], System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out parsedValue))
                                            {
                                                _values[i] = parsedValue;
                                            }
                                        }
                                    }

                                    _var.FloatArrayValue = _values;
                                    break;
                                }

Adding "FloatArray" variable

Comments

Howdy, Stranger!

Categories

Adding "FloatArray" variable

Comments

Howdy, Stranger!

Quick Links

Categories