Ejemplo n.º 1
0
    /*
     * public static implicit operator string(ProgressPoint value)
     * {
     *  return value.ProgressName;
     * }
     *
     * public static implicit operator ProgressPoint(string value)
     * {
     *  return new ProgressPoint(value);
     * }
     */

    public ProgressPoint(JsonData data)
    {
        ProgressName = (string)data["Name"];
        TypeID       = (PointTypes)(int)data["Type"];


        switch (TypeID)
        {
        case PointTypes.Flag:
            BoolValue = (bool)data["MatchValue"];
            break;

        case PointTypes.Float:
            FloatValue = (float)(double)data["MatchValue"];
            compare    = (ValueCompare)(int)data["Compare"];
            break;

        case PointTypes.Integer:
            IntValue = (int)data["MatchValue"];
            compare  = (ValueCompare)(int)data["Compare"];
            break;

        case PointTypes.String:
            StringValue = (string)data["MatchValue"];
            break;

        default:
            break;
        }
    }
Ejemplo n.º 2
0
 public ProgressPoint(ProgressPoint copy_)
 {
     ProgressName = copy_.ProgressName;
     TypeID       = copy_.TypeID;
     StringValue  = copy_.StringValue;
     BoolValue    = copy_.BoolValue;
     IntValue     = copy_.IntValue;
     FloatValue   = copy_.FloatValue;
     compare      = copy_.compare;
 }
Ejemplo n.º 3
0
        public bool Compare(bool val, ValueCompare compare)
        {
            switch (compare)
            {
            case ValueCompare.Equal:
                return(val == BoolValue);

            case ValueCompare.NotEqual:
                return(val != BoolValue);
            }
            return(false);
        }
Ejemplo n.º 4
0
    public static bool CompareValues(ValueCompare Compare, float a, float b)
    {
        switch (Compare)
        {
        case ValueCompare.EqualTo:
            return(a == b);

        case ValueCompare.GreaterThan:
            return(a > b);

        case ValueCompare.LessThan:
            return(a < b);

        default:
            return(false);
        }
    }
Ejemplo n.º 5
0
        public bool Compare(string v, ValueCompare compare)
        {
            switch (ValueType)
            {
            case VarType.INT:
                return(Compare(Convert.ToInt32(v), compare));

            case VarType.FLOAT:
                return(Compare(Convert.ToSingle(v), compare));

            case VarType.BOOL:
                return(Compare(Convert.ToBoolean(v), compare));

            case VarType.STRING:
                return(StringValue == v);
            }

            return(false);
        }
Ejemplo n.º 6
0
        public bool Compare(float val, ValueCompare compare)
        {
            switch (compare)
            {
            case ValueCompare.Equal:
                return(FloatValue == val);

            case ValueCompare.NotEqual:
                return(FloatValue != val);

            case ValueCompare.Less:
                return(FloatValue < val);

            case ValueCompare.Greater:
                return(FloatValue > val);

            case ValueCompare.LessEqual:
                return(FloatValue <= val);

            case ValueCompare.GreaterEqual:
                return(FloatValue >= val);
            }
            return(false);
        }
Ejemplo n.º 7
0
 public CombatItemValueChecker(long value, ValueCompare compare)
 {
     _value   = value;
     _compare = compare;
 }
Ejemplo n.º 8
0
 public bool Compare(float val, ValueCompare compare)
 {
     switch (compare)
     {
         case ValueCompare.Equal:
             return FloatValue == val;
         case ValueCompare.NotEqual:
             return FloatValue != val;
         case ValueCompare.Less:
             return FloatValue < val;
         case ValueCompare.Greater:
             return FloatValue > val;
         case ValueCompare.LessEqual:
             return FloatValue <= val;
         case ValueCompare.GreaterEqual:
             return FloatValue >= val;
     }
     return false;
 }
Ejemplo n.º 9
0
 public bool Compare(bool val, ValueCompare compare)
 {
     switch (compare)
     {
         case ValueCompare.Equal:
             return val == BoolValue;
         case ValueCompare.NotEqual:
             return val != BoolValue;
     }
     return false;
 }
Ejemplo n.º 10
0
        public bool Compare(string v, ValueCompare compare)
        {
            switch (ValueType)
            {
                case VarType.INT:
                    return Compare(Convert.ToInt32(v), compare);
                case VarType.FLOAT:
                    return Compare(Convert.ToSingle(v), compare);
                case VarType.BOOL:
                    return Compare(Convert.ToBoolean(v), compare);
                case VarType.STRING:
                    return StringValue == v;
            }

            return false;
        }
Ejemplo n.º 11
0
        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            EditorGUI.BeginProperty(position, label, property);


            var refer  = property.FindPropertyRelative("ProgressName");
            var refer2 = property.FindPropertyRelative("TypeID");

            var labelRect = new Rect(position.x, position.y, InspectorValues.LabelWidth, position.height);

            EditorGUI.LabelField(labelRect, property.name);


            //this is defining the sizes of the rectangles for the editor
            var propStartPos = labelRect.position.x + labelRect.width;

            if (position.width > InspectorValues.MinRectWidth)
            {
                propStartPos += (position.width - InspectorValues.MinRectWidth) / InspectorValues.WidthScaler;
            }

            var toggleRect = new Rect(propStartPos, position.y, ToggleWidth, EditorGUIUtility.singleLineHeight);
            var eventRect  = new Rect(toggleRect.position.x + toggleRect.width, position.y, position.width - (toggleRect.position.x + toggleRect.width) + 14, EditorGUIUtility.singleLineHeight);

            //var enumRect = new Rect(propStartPos, position.y, 40, EditorGUIUtility.singleLineHeight);

            refer.stringValue = EditorGUI.TextField(eventRect, refer.stringValue);
            PointTypes ty = (PointTypes)EditorGUI.EnumPopup(toggleRect, (PointTypes)refer2.enumValueIndex);

            refer2.enumValueIndex = (int)ty;
            //ref2.boolValue = EditorGUI.ToggleLeft(toggleRect, "Value", ref2.boolValue);

            switch (ty)
            {
            case PointTypes.Flag:
                var refboo = property.FindPropertyRelative("BoolValue");
                toggleRect.y    += EditorGUIUtility.singleLineHeight + 2;
                refboo.boolValue = EditorGUI.ToggleLeft(toggleRect, "Value", refboo.boolValue);
                break;

            case PointTypes.Float:
                var refflo = property.FindPropertyRelative("FloatValue");

                eventRect.y      += EditorGUIUtility.singleLineHeight + 2;
                refflo.floatValue = EditorGUI.FloatField(eventRect, refflo.floatValue);

                var compare = property.FindPropertyRelative("compare");
                toggleRect.y += EditorGUIUtility.singleLineHeight + 2;
                ValueCompare com = (ValueCompare)EditorGUI.EnumPopup(toggleRect, (ValueCompare)compare.enumValueIndex);
                compare.enumValueIndex = (int)com;
                break;

            case PointTypes.Integer:
                var refint = property.FindPropertyRelative("IntValue");

                eventRect.y    += EditorGUIUtility.singleLineHeight + 2;
                refint.intValue = EditorGUI.IntField(eventRect, refint.intValue);

                var compare2 = property.FindPropertyRelative("compare");
                toggleRect.y += EditorGUIUtility.singleLineHeight + 2;
                ValueCompare com2 = (ValueCompare)EditorGUI.EnumPopup(toggleRect, (ValueCompare)compare2.enumValueIndex);
                compare2.enumValueIndex = (int)com2;
                break;

            case PointTypes.String:
                var refst = property.FindPropertyRelative("StringValue");
                eventRect.y      += EditorGUIUtility.singleLineHeight + 2;
                refst.stringValue = EditorGUI.TextField(eventRect, refst.stringValue);
                break;

            default:
                break;
            }


            EditorGUI.EndProperty();
        }
Ejemplo n.º 12
0
    public ProgressNode(Vector2 position, float width, float height, GUIStyle nodeStyle, GUIStyle selectedStyle, GUIStyle inPointStyle, GUIStyle outPointStyle, Action <ConnectionPoint> OnClickInPoint, Action <ConnectionPoint> OnClickOutPoint, Action <BaseNode> OnClickRemoveNode, Action <BaseNode> OnClickDuplicateNode, JsonData data) : base(position, width, height, nodeStyle, selectedStyle, inPointStyle, outPointStyle, OnClickInPoint, OnClickOutPoint, OnClickRemoveNode, OnClickDuplicateNode)
    {
        inPoint        = new ProgressionConnectionPoint(this, ConnectionPointType.In, inPointStyle, OnClickInPoint);
        outPoint       = new ProgressionConnectionPoint(this, ConnectionPointType.Out, outPointStyle, OnClickOutPoint);
        BranchOutPoint = new ProgressionConnectionPoint(this, ConnectionPointType.Branch, outPointStyle, OnClickOutPoint);


        if (data.Keys.Contains("color"))
        {
            ChangeColor((int)data["color"]);
        }

        TypeID = NodeTypes.ProgressNode;

        if (data.Keys.Contains("TypeOfProgress"))
        {
            int ty = (int)data["TypeOfProgress"];
            TypeOfProgress = (ProgressType)ty;
        }
        else
        {
            TypeOfProgress = ProgressType.ProgressPoint;
        }


        ID = (int)data["ID"];

        PassID = (int)data["PassID"];
        FailID = (int)data["FailID"];

        title = (string)data["title"];

        //CheckToMatch = (string)data["CheckToMatch"];
        //MatchValue = (bool)data["MatchValue"];

        if (data.Keys.Contains("CheckToMatch"))
        {
            CheckPoint = new ProgressPoint(data["CheckToMatch"][0]);
        }
        else
        {
            CheckPoint = new ProgressPoint();
        }



        if (data.Keys.Contains("Comparison"))
        {
            int com = (int)data["Comparison"];
            Compare = (ValueCompare)com;
        }
        else
        {
            Compare = ValueCompare.EqualTo;
        }



        if (data.Keys.Contains("Slug") && data["Slug"] != null)
        {
            InventoryMatch = Resources.Load("Sprites/" + (string)data["Slug"]) as Texture2D;
        }



        if (data.Keys.Contains("NoteTitle"))
        {
            NoteTitle = (string)data["NoteTitle"];
        }
        else
        {
            NoteTitle = "";
        }



        if (data.Keys.Contains("PhoneImageSlug") && data["PhoneImageSlug"] != null)
        {
            Image = Resources.Load <Sprite>("Sprites/" + (string)data["PhoneImageSlug"]);
        }

        if (data.Keys.Contains("Current"))
        {
            Current = (bool)data["Current"];
        }
        else
        {
            Current = false;
        }

        if (data.Keys.Contains("TaskNumber"))
        {
            TaskNumber = (int)data["TaskNumber"];
        }
        else
        {
            TaskNumber = 0;
        }

        if (data.Keys.Contains("TaskState"))
        {
            int state = (int)data["TaskState"];
            NewTaskState = (Task.TaskState)state;
        }
        else
        {
            NewTaskState = Task.TaskState.Unstarted;
        }

        if (data.Keys.Contains("Battery"))
        {
            Battery = (int)data["Battery"];
        }
        else
        {
            Battery = 0;
        }

        if (data.Keys.Contains("Drain"))
        {
            Drain = (float)(double)data["Drain"];
        }
        else
        {
            Drain = 0;
        }

        if (data.Keys.Contains("BeatName"))
        {
            BeatName = (string)data["BeatName"];
        }
        else
        {
            BeatName = "";
        }


        if (data.Keys.Contains("Previous"))
        {
            PreviousScene = (bool)data["Previous"];
        }
        else
        {
            PreviousScene = false;
        }

        if (data.Keys.Contains("Date"))
        {
            int date = (int)data["Date"];
            Date = (DayOfWeek)date;
        }
        else
        {
            Date = DayOfWeek.Monday;
        }

        if (data.Keys.Contains("Dream"))
        {
            DreamName = (string)data["Dream"];
        }
        else
        {
            DreamName = "";
        }
    }