You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
268 lines
8.3 KiB
268 lines
8.3 KiB
@tool
|
|
extends DialogicVisualEditorField
|
|
|
|
## Event block field for displaying conditions in either a simple or complex way.
|
|
|
|
var _current_value1 :Variant = ""
|
|
var _current_value2 :Variant = ""
|
|
|
|
#region MAIN METHODS
|
|
################################################################################
|
|
|
|
func _set_value(value:Variant) -> void:
|
|
var too_complex := is_too_complex(value)
|
|
%ToggleComplex.disabled = too_complex
|
|
%ToggleComplex.button_pressed = too_complex
|
|
%ComplexEditor.visible = too_complex
|
|
%SimpleEditor.visible = !too_complex
|
|
%ComplexEditor.text = value
|
|
if not too_complex:
|
|
load_simple_editor(value)
|
|
|
|
|
|
|
|
func _autofocus():
|
|
%Value1Variable.grab_focus()
|
|
|
|
#endregion
|
|
|
|
func _ready() -> void:
|
|
for i in [%Value1Type, %Value2Type]:
|
|
i.options = [{
|
|
'label': 'String',
|
|
'icon': ["String", "EditorIcons"],
|
|
'value': 0
|
|
},{
|
|
'label': 'Number',
|
|
'icon': ["float", "EditorIcons"],
|
|
'value': 1
|
|
},{
|
|
'label': 'Variable',
|
|
'icon': load("res://addons/dialogic/Editor/Images/Pieces/variable.svg"),
|
|
'value': 2
|
|
},{
|
|
'label': 'Bool',
|
|
'icon': ["bool", "EditorIcons"],
|
|
'value': 3
|
|
},{
|
|
'label': 'Expression',
|
|
'icon': ["Variant", "EditorIcons"],
|
|
'value': 4
|
|
}]
|
|
i.symbol_only = true
|
|
i.value_changed.connect(value_type_changed.bind(i.name))
|
|
i.value_changed.connect(something_changed)
|
|
i.tooltip_text = "Change type"
|
|
|
|
|
|
for i in [%Value1Variable, %Value2Variable]:
|
|
i.get_suggestions_func = get_variable_suggestions
|
|
i.value_changed.connect(something_changed)
|
|
|
|
%Value1Number.value_changed.connect(something_changed)
|
|
%Value2Number.value_changed.connect(something_changed)
|
|
%Value1Text.value_changed.connect(something_changed)
|
|
%Value2Text.value_changed.connect(something_changed)
|
|
%Value1Bool.value_changed.connect(something_changed)
|
|
%Value2Bool.value_changed.connect(something_changed)
|
|
|
|
%ToggleComplex.icon = get_theme_icon("Enum", "EditorIcons")
|
|
|
|
%Operator.value_changed.connect(something_changed)
|
|
%Operator.options = [
|
|
{'label': '==', 'value': '=='},
|
|
{'label': '>', 'value': '>'},
|
|
{'label': '<', 'value': '<'},
|
|
{'label': '<=', 'value': '<='},
|
|
{'label': '>=', 'value': '>='},
|
|
{'label': '!=', 'value': '!='}
|
|
]
|
|
|
|
|
|
func load_simple_editor(condition_string:String) -> void:
|
|
var data := complex2simple(condition_string)
|
|
%Value1Type.set_value(get_value_type(data[0], 2))
|
|
_current_value1 = data[0]
|
|
value_type_changed('', get_value_type(data[0], 2), 'Value1')
|
|
%Operator.set_value(data[1].strip_edges())
|
|
%Value2Type.set_value(get_value_type(data[2], 0))
|
|
_current_value2 = data[2]
|
|
value_type_changed('', get_value_type(data[2], 0), 'Value2')
|
|
|
|
|
|
func value_type_changed(property:String, value_type:int, value_name:String) -> void:
|
|
value_name = value_name.trim_suffix('Type')
|
|
get_node('%'+value_name+'Variable').hide()
|
|
get_node('%'+value_name+'Text').hide()
|
|
get_node('%'+value_name+'Number').hide()
|
|
get_node('%'+value_name+'Bool').hide()
|
|
var current_val :Variant = ""
|
|
if '1' in value_name:
|
|
current_val = _current_value1
|
|
else:
|
|
current_val = _current_value2
|
|
match value_type:
|
|
0:
|
|
get_node('%'+value_name+'Text').show()
|
|
get_node('%'+value_name+'Text').set_value(trim_value(current_val, value_type))
|
|
1:
|
|
get_node('%'+value_name+'Number').show()
|
|
get_node('%'+value_name+'Number').set_value(float(current_val.strip_edges()))
|
|
2:
|
|
get_node('%'+value_name+'Variable').show()
|
|
get_node('%'+value_name+'Variable').set_value(trim_value(current_val, value_type))
|
|
3:
|
|
get_node('%'+value_name+'Bool').show()
|
|
get_node('%'+value_name+'Bool').set_value(trim_value(current_val, value_type))
|
|
4:
|
|
get_node('%'+value_name+'Text').show()
|
|
get_node('%'+value_name+'Text').set_value(str(current_val))
|
|
|
|
|
|
func get_value_type(value:String, default:int) -> int:
|
|
value = value.strip_edges()
|
|
if value.begins_with('"') and value.ends_with('"') and value.count('"')-value.count('\\"') == 2:
|
|
return 0
|
|
elif value.begins_with('{') and value.ends_with('}') and value.count('{') == 1:
|
|
return 2
|
|
elif value == "true" or value == "false":
|
|
return 3
|
|
else:
|
|
if value.is_empty():
|
|
return default
|
|
if value.is_valid_float():
|
|
return 1
|
|
else:
|
|
return 4
|
|
|
|
|
|
func prep_value(value:Variant, value_type:int) -> String:
|
|
if value != null: value = str(value)
|
|
else: value = ""
|
|
value = value.strip_edges()
|
|
match value_type:
|
|
0: return '"'+value.replace('"', '\\"')+'"'
|
|
2: return '{'+value+'}'
|
|
_: return value
|
|
|
|
|
|
func trim_value(value:Variant, value_type:int) -> String:
|
|
value = value.strip_edges()
|
|
match value_type:
|
|
0: return value.trim_prefix('"').trim_suffix('"').replace('\\"', '"')
|
|
2: return value.trim_prefix('{').trim_suffix('}')
|
|
3:
|
|
if value == "true" or (value and (typeof(value) != TYPE_STRING or value != "false")):
|
|
return "true"
|
|
else:
|
|
return "false"
|
|
_: return value
|
|
|
|
|
|
func something_changed(fake_arg1=null, fake_arg2 = null):
|
|
if %ComplexEditor.visible:
|
|
value_changed.emit(property_name, %ComplexEditor.text)
|
|
return
|
|
|
|
|
|
match %Value1Type.current_value:
|
|
0: _current_value1 = prep_value(%Value1Text.text, %Value1Type.current_value)
|
|
1: _current_value1 = str(%Value1Number.get_value())
|
|
2: _current_value1 = prep_value(%Value1Variable.current_value, %Value1Type.current_value)
|
|
3: _current_value1 = prep_value(%Value1Bool.button_pressed, %Value1Type.current_value)
|
|
_: _current_value1 = prep_value(%Value1Text.text, %Value1Type.current_value)
|
|
|
|
match %Value2Type.current_value:
|
|
0: _current_value2 = prep_value(%Value2Text.text, %Value2Type.current_value)
|
|
1: _current_value2 = str(%Value2Number.get_value())
|
|
2: _current_value2 = prep_value(%Value2Variable.current_value, %Value2Type.current_value)
|
|
3: _current_value2 = prep_value(%Value2Bool.button_pressed, %Value2Type.current_value)
|
|
_: _current_value2 = prep_value(%Value2Text.text, %Value2Type.current_value)
|
|
|
|
if event_resource:
|
|
if not %Operator.text in ['==', '!='] and get_value_type(_current_value2, 0) in [0, 3]:
|
|
event_resource.ui_update_warning.emit("This operator doesn't work with strings and booleans.")
|
|
else:
|
|
event_resource.ui_update_warning.emit("")
|
|
|
|
value_changed.emit(property_name, get_simple_condition())
|
|
|
|
|
|
func is_too_complex(condition:String) -> bool:
|
|
if condition.strip_edges().is_empty():
|
|
return false
|
|
|
|
var comparison_count: int = 0
|
|
for i in ['==', '!=', '<=', '<', '>', '>=']:
|
|
comparison_count += condition.count(i)
|
|
if comparison_count == 1:
|
|
return false
|
|
|
|
return true
|
|
|
|
|
|
## Combines the info from the simple editor fields into a string condition
|
|
func get_simple_condition() -> String:
|
|
return _current_value1 +" "+ %Operator.text +" "+ _current_value2
|
|
|
|
|
|
func complex2simple(condition:String) -> Array:
|
|
if is_too_complex(condition) or condition.strip_edges().is_empty():
|
|
return ['', '==','']
|
|
|
|
for i in ['==', '!=', '<=', '<', '>', '>=']:
|
|
if i in condition:
|
|
var cond_split := Array(condition.split(i, false))
|
|
return [cond_split[0], i, cond_split[1]]
|
|
|
|
return ['', '==','']
|
|
|
|
|
|
func _on_toggle_complex_toggled(button_pressed:bool) -> void:
|
|
if button_pressed:
|
|
%ComplexEditor.show()
|
|
%SimpleEditor.hide()
|
|
%ComplexEditor.text = get_simple_condition()
|
|
else:
|
|
if !is_too_complex(%ComplexEditor.text):
|
|
%ComplexEditor.hide()
|
|
%SimpleEditor.show()
|
|
load_simple_editor(%ComplexEditor.text)
|
|
|
|
|
|
func _on_complex_editor_text_changed(new_text:String) -> void:
|
|
%ToggleComplex.disabled = is_too_complex(%ComplexEditor.text)
|
|
something_changed()
|
|
|
|
|
|
func get_variable_suggestions(filter:String) -> Dictionary:
|
|
var suggestions := {}
|
|
var vars :Dictionary= ProjectSettings.get_setting('dialogic/variables', {})
|
|
for var_path in DialogicUtil.list_variables(vars):
|
|
suggestions[var_path] = {'value':var_path, 'editor_icon':["ClassList", "EditorIcons"]}
|
|
return suggestions
|
|
|
|
|
|
func _on_value_1_variable_value_changed(property_name: Variant, value: Variant) -> void:
|
|
var type := DialogicUtil.get_variable_type(value)
|
|
match type:
|
|
DialogicUtil.VarTypes.BOOL:
|
|
if not %Operator.text in ["==", "!="]:
|
|
%Operator.text = "=="
|
|
if get_value_type(_current_value2, 3) in [0, 1]:
|
|
%Value2Type.insert_options()
|
|
%Value2Type.index_pressed(3)
|
|
DialogicUtil.VarTypes.STRING:
|
|
if not %Operator.text in ["==", "!="]:
|
|
%Operator.text = "=="
|
|
if get_value_type(_current_value2, 0) in [1, 3]:
|
|
%Value2Type.insert_options()
|
|
%Value2Type.index_pressed(0)
|
|
DialogicUtil.VarTypes.FLOAT, DialogicUtil.VarTypes.INT:
|
|
if get_value_type(_current_value2, 1) in [0,3]:
|
|
%Value2Type.insert_options()
|
|
%Value2Type.index_pressed(1)
|
|
|
|
something_changed()
|
|
|