condition_evaluator.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
 
 
func matches(conditions:Dictionary, context:Dictionary = {}) -> bool:
    if conditions.is_empty():
        return true
    for key in conditions.keys():
        var expected = conditions[key]
        if str(key) == "all" and expected is Array:
            for child in expected:
                if child is Dictionary and not matches(child, context):
                    return false
            continue
        if str(key) == "any" and expected is Array:
            var matched := false
            for child in expected:
                if child is Dictionary and matches(child, context):
                    matched = true
                    break
            if not matched:
                return false
            continue
        if str(key) == "not" and expected is Dictionary:
            if matches(expected, context):
                return false
            continue
        if not _value_matches(value_at(context, str(key)), expected):
            return false
    return true
 
 
 
func value_at(context:Dictionary, dotted_key:String, default_value = null):
    var current = context
    for part in dotted_key.split("."):
        if current is Dictionary and current.has(part):
            current = current[part]
        else:
            return default_value
    return current
 
 
func _value_matches(actual, expected) -> bool:
    if expected is Dictionary:
        if expected.has("exists"):
            return (actual != null) == bool(expected.get("exists", true))
        if expected.has("equals") and actual != expected.get("equals"):
            return false
        if expected.has("not_equals") and actual == expected.get("not_equals"):
            return false
        if expected.has("at_least") and _to_float(actual) < _to_float(expected.get("at_least", 0.0)):
            return false
        if expected.has("at_most") and _to_float(actual) > _to_float(expected.get("at_most", 0.0)):
            return false
        if expected.has("greater_than") and _to_float(actual) <= _to_float(expected.get("greater_than", 0.0)):
            return false
        if expected.has("less_than") and _to_float(actual) >= _to_float(expected.get("less_than", 0.0)):
            return false
        if expected.has("contains"):
            if actual is Array:
                if not actual.has(expected.get("contains")):
                    return false
            elif not str(actual).contains(str(expected.get("contains"))):
                return false
        if expected.has("in"):
            var allowed = expected.get("in")
            if not allowed is Array or not allowed.has(actual):
                return false
        return true
    return actual == expected
 
 
func _to_float(value) -> float:
    if value is int or value is float:
        return float(value)
    if value is bool:
        return 1.0 if value else 0.0
    if value == null:
        return 0.0
    return str(value).to_float()