public bool CompareTo(WorldDate otherDate, InequalityTypes inequalityTypeThanOther, bool checkHours, bool otherIsNextDay)
    {
        int thisToSeconds  = (checkHours) ? this.ToSecondsHoursOnly(false) : this.ToSeconds();
        int otherToSeconds = (checkHours) ? this.ToSecondsHoursOnly(otherIsNextDay) : this.ToSeconds();

        bool result = false;

        switch (inequalityTypeThanOther)
        {
        case InequalityTypes.Equal:
            result = thisToSeconds == otherToSeconds;
            break;

        case InequalityTypes.Greater:
            result = thisToSeconds > otherToSeconds;
            break;

        case InequalityTypes.GreaterOrEqual:
            result = thisToSeconds >= otherToSeconds;
            break;

        case InequalityTypes.Less:
            result = thisToSeconds < otherToSeconds;
            break;

        case InequalityTypes.LessOrEqual:
            result = thisToSeconds <= otherToSeconds;
            break;
        }

        return(result);
    }
    public void SetWorldDateCondition(WorldDate date, InequalityTypes beforeOrAfter)
    {
        conditionTypeSet = ConditionTypes.WorldDate;

        if (WorldDate == null)
        {
            worldDateCondition = new WorldDateCondition();
        }

        worldDateCondition.Date            = date;
        worldDateCondition.TimeOrientation = beforeOrAfter;
    }
    public void SetStatisticCheckCondition(CharacterStatistic statistic, InequalityTypes ineqType, float valueToCheck)
    {
        conditionTypeSet = ConditionTypes.StatisticCheck;

        if (statisticCheckCondition == null)
        {
            statisticCheckCondition = new StatisticsCheckCondition();
        }

        statisticCheckCondition.InequalityType = ineqType;
        statisticCheckCondition.Statistic      = statistic;
        statisticCheckCondition.ValueChecked   = valueToCheck;
    }
    public void SetAttributeCheckCondition(CharacterAttribute stat, int value, InequalityTypes type)
    {
        conditionTypeSet = ConditionTypes.AttributeCheck;

        if (attributeCheckCondition == null)
        {
            attributeCheckCondition = new AttributeCheckCondition();
        }

        attributeCheckCondition.Attribute      = stat;
        attributeCheckCondition.ValueChecked   = value;
        attributeCheckCondition.InequalityType = type;
    }
示例#5
0
    bool DrawInequalityField(InequalityTypes prevType, int labelWidth, out InequalityTypes inequality)
    {
        bool result = false;

        GUILayout.BeginHorizontal();
        {
            EditorGUILayout.PrefixLabel("Inequality" /*, GUILayout.Width(labelWidth)*/);
            inequality = (InequalityTypes)EditorGUILayout.EnumPopup(prevType);

            result |= prevType != inequality;
        }
        GUILayout.EndHorizontal();

        return(result);
    }
示例#6
0
    public static string Name(this InequalityTypes type)
    {
        switch (type)
        {
        case InequalityTypes.Equal: return("Equals");

        case InequalityTypes.Greater: return("Greater Than");

        case InequalityTypes.GreaterOrEqual: return("Greater Than Or Equal To");

        case InequalityTypes.Less: return("Less Than");

        case InequalityTypes.LessOrEqual: return("Less Than Or Equal To");

        default: return("");
        }
    }
示例#7
0
    public static bool Value(this InequalityTypes type, float Prev, float Next)
    {
        switch (type)
        {
        case InequalityTypes.Equal:
            return(Prev == Next);

        case InequalityTypes.Greater:
            return(Prev > Next);

        case InequalityTypes.GreaterOrEqual:
            return(Prev >= Next);

        case InequalityTypes.Less:
            return(Prev < Next);

        case InequalityTypes.LessOrEqual:
            return(Prev <= Next);

        default: return(false);
        }
    }