visual_script_nodes.cpp

/**************************************************************************/
/*  visual_script_nodes.cpp                                               */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "visual_script_nodes.h"

#include "core/config/engine.h"
#include "core/config/project_settings.h"
#include "core/core_constants.h"
#include "core/input/input.h"
#include "core/os/os.h"
#include "scene/main/node.h"
#include "scene/main/scene_tree.h"

//////////////////////////////////////////
////////////////FUNCTION//////////////////
//////////////////////////////////////////

bool VisualScriptFunction::_set(const StringName &p_name,
		const Variant &p_value) {
	if (p_name == "argument_count") {
		int new_argc = p_value;
		int argc = arguments.size();
		if (argc == new_argc) {
			return true;
		}

		arguments.resize(new_argc);

		for (int i = argc; i < new_argc; i++) {
			arguments.write[i].name = "arg" + itos(i + 1);
			arguments.write[i].type = Variant::NIL;
		}
		ports_changed_notify();
		notify_property_list_changed();
		return true;
	}
	if (String(p_name).begins_with("argument_")) {
		int idx = String(p_name).get_slicec('_', 1).get_slicec('/', 0).to_int() - 1;
		ERR_FAIL_INDEX_V(idx, arguments.size(), false);
		String what = String(p_name).get_slice("/", 1);
		if (what == "type") {
			Variant::Type new_type = Variant::Type(int(p_value));
			arguments.write[idx].type = new_type;
			ports_changed_notify();

			return true;
		}

		if (what == "name") {
			arguments.write[idx].name = p_value;
			ports_changed_notify();
			return true;
		}
	}

	if (p_name == "stack/stackless") {
		set_stack_less(p_value);
		return true;
	}

	if (p_name == "stack/size") {
		stack_size = p_value;
		return true;
	}

	if (p_name == "rpc/mode") {
		rpc_mode = MultiplayerAPI::RPCMode(int(p_value));
		return true;
	}

	if (p_name == "sequenced/sequenced") {
		sequenced = p_value;
		ports_changed_notify();
		return true;
	}

	return false;
}

bool VisualScriptFunction::_get(const StringName &p_name,
		Variant &r_ret) const {
	if (p_name == "argument_count") {
		r_ret = arguments.size();
		return true;
	}
	if (String(p_name).begins_with("argument_")) {
		int idx = String(p_name).get_slicec('_', 1).get_slicec('/', 0).to_int() - 1;
		ERR_FAIL_INDEX_V(idx, arguments.size(), false);
		String what = String(p_name).get_slice("/", 1);
		if (what == "type") {
			r_ret = arguments[idx].type;
			return true;
		}
		if (what == "name") {
			r_ret = arguments[idx].name;
			return true;
		}
	}

	if (p_name == "stack/stackless") {
		r_ret = stack_less;
		return true;
	}

	if (p_name == "stack/size") {
		r_ret = stack_size;
		return true;
	}

	if (p_name == "rpc/mode") {
		r_ret = rpc_mode;
		return true;
	}

	if (p_name == "sequenced/sequenced") {
		r_ret = sequenced;
		return true;
	}

	return false;
}

void VisualScriptFunction::_get_property_list(
		List<PropertyInfo> *p_list) const {
	p_list->push_back(PropertyInfo(Variant::INT, "argument_count",
			PROPERTY_HINT_RANGE, "0,256"));
	String argt = "Any";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	for (int i = 0; i < arguments.size(); i++) {
		p_list->push_back(PropertyInfo(Variant::INT,
				"argument_" + itos(i + 1) + "/type",
				PROPERTY_HINT_ENUM, argt));
		p_list->push_back(
				PropertyInfo(Variant::STRING, "argument_" + itos(i + 1) + "/name"));
	}

	p_list->push_back(PropertyInfo(Variant::BOOL, "sequenced/sequenced"));

	if (!stack_less) {
		p_list->push_back(PropertyInfo(Variant::INT, "stack/size",
				PROPERTY_HINT_RANGE, "1,100000"));
	}
	p_list->push_back(PropertyInfo(Variant::BOOL, "stack/stackless"));
	p_list->push_back(PropertyInfo(Variant::INT, "rpc/mode", PROPERTY_HINT_ENUM,
			"Disabled,Any,Authority"));
}

int VisualScriptFunction::get_output_sequence_port_count() const { return 1; }

bool VisualScriptFunction::has_input_sequence_port() const { return false; }

int VisualScriptFunction::get_input_value_port_count() const { return 0; }

int VisualScriptFunction::get_output_value_port_count() const {
	return arguments.size();
}

String VisualScriptFunction::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptFunction::get_input_value_port_info(int p_idx) const {
	ERR_FAIL_V(PropertyInfo());
}

PropertyInfo VisualScriptFunction::get_output_value_port_info(int p_idx) const {
	// Need to check it without ERR_FAIL_COND, to prevent warnings from appearing
	// on node creation via dragging.
	if (p_idx < 0 || p_idx >= arguments.size()) {
		return PropertyInfo();
	}
	PropertyInfo out;
	out.type = arguments[p_idx].type;
	out.name = arguments[p_idx].name;
	out.hint = arguments[p_idx].hint;
	out.hint_string = arguments[p_idx].hint_string;
	return out;
}

String VisualScriptFunction::get_caption() const { return RTR("Function"); }

String VisualScriptFunction::get_text() const {
	return get_name(); // use name as function name I guess
}

void VisualScriptFunction::add_argument(Variant::Type p_type,
		const String &p_name, int p_index,
		const PropertyHint p_hint,
		const String &p_hint_string) {
	Argument arg;
	arg.name = p_name;
	arg.type = p_type;
	arg.hint = p_hint;
	arg.hint_string = p_hint_string;
	if (p_index >= 0) {
		arguments.insert(p_index, arg);
	} else {
		arguments.push_back(arg);
	}

	ports_changed_notify();
}

void VisualScriptFunction::set_argument_type(int p_argidx,
		Variant::Type p_type) {
	ERR_FAIL_INDEX(p_argidx, arguments.size());

	arguments.write[p_argidx].type = p_type;
	ports_changed_notify();
}

Variant::Type VisualScriptFunction::get_argument_type(int p_argidx) const {
	ERR_FAIL_INDEX_V(p_argidx, arguments.size(), Variant::NIL);
	return arguments[p_argidx].type;
}

void VisualScriptFunction::set_argument_name(int p_argidx,
		const String &p_name) {
	ERR_FAIL_INDEX(p_argidx, arguments.size());

	arguments.write[p_argidx].name = p_name;
	ports_changed_notify();
}

String VisualScriptFunction::get_argument_name(int p_argidx) const {
	ERR_FAIL_INDEX_V(p_argidx, arguments.size(), String());
	return arguments[p_argidx].name;
}

void VisualScriptFunction::remove_argument(int p_argidx) {
	ERR_FAIL_INDEX(p_argidx, arguments.size());

	arguments.remove_at(p_argidx);
	ports_changed_notify();
}

int VisualScriptFunction::get_argument_count() const {
	return arguments.size();
}

void VisualScriptFunction::set_rpc_mode(MultiplayerAPI::RPCMode p_mode) {
	rpc_mode = p_mode;
}

MultiplayerAPI::RPCMode VisualScriptFunction::get_rpc_mode() const {
	return rpc_mode;
}

class VisualScriptNodeInstanceFunction : public VisualScriptNodeInstance {
public:
	VisualScriptFunction *node = nullptr;
	VisualScriptInstance *instance = nullptr;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		int ac = node->get_argument_count();

		for (int i = 0; i < ac; i++) {
#ifdef DEBUG_ENABLED
			Variant::Type expected = node->get_argument_type(i);
			if (expected != Variant::NIL) {
				if (!Variant::can_convert_strict(p_inputs[i]->get_type(), expected)) {
					r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
					r_error.expected = expected;
					r_error.argument = i;
					return 0;
				}
			}
#endif

			*p_outputs[i] = *p_inputs[i];
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptFunction::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceFunction *instance =
			memnew(VisualScriptNodeInstanceFunction);
	instance->node = this;
	instance->instance = p_instance;
	return instance;
}

void VisualScriptFunction::reset_state() {
	arguments.clear();
	stack_size = 256;
	stack_less = false;
	sequenced = true;
	rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
}

VisualScriptFunction::VisualScriptFunction() {
	stack_size = 256;
	stack_less = false;
	sequenced = true;
	rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
}

void VisualScriptFunction::set_stack_less(bool p_enable) {
	stack_less = p_enable;
	notify_property_list_changed();
}

bool VisualScriptFunction::is_stack_less() const { return stack_less; }

void VisualScriptFunction::set_sequenced(bool p_enable) {
	sequenced = p_enable;
}

bool VisualScriptFunction::is_sequenced() const { return sequenced; }

void VisualScriptFunction::set_stack_size(int p_size) {
	ERR_FAIL_COND(p_size < 1 || p_size > 100000);
	stack_size = p_size;
}

int VisualScriptFunction::get_stack_size() const { return stack_size; }

//////////////////////////////////////////
/////////////////LISTS////////////////////
//////////////////////////////////////////

int VisualScriptLists::get_output_sequence_port_count() const {
	if (sequenced) {
		return 1;
	}
	return 0;
}

bool VisualScriptLists::has_input_sequence_port() const { return sequenced; }

String VisualScriptLists::get_output_sequence_port_text(int p_port) const {
	return "";
}

int VisualScriptLists::get_input_value_port_count() const {
	return inputports.size();
}

int VisualScriptLists::get_output_value_port_count() const {
	return outputports.size();
}

PropertyInfo VisualScriptLists::get_input_value_port_info(int p_idx) const {
	ERR_FAIL_INDEX_V(p_idx, inputports.size(), PropertyInfo());

	PropertyInfo pi;
	pi.name = inputports[p_idx].name;
	pi.type = inputports[p_idx].type;
	return pi;
}

PropertyInfo VisualScriptLists::get_output_value_port_info(int p_idx) const {
	ERR_FAIL_INDEX_V(p_idx, outputports.size(), PropertyInfo());

	PropertyInfo pi;
	pi.name = outputports[p_idx].name;
	pi.type = outputports[p_idx].type;
	return pi;
}

bool VisualScriptLists::is_input_port_editable() const {
	return ((flags & INPUT_EDITABLE) == INPUT_EDITABLE);
}

bool VisualScriptLists::is_input_port_name_editable() const {
	return ((flags & INPUT_NAME_EDITABLE) == INPUT_NAME_EDITABLE);
}

bool VisualScriptLists::is_input_port_type_editable() const {
	return ((flags & INPUT_TYPE_EDITABLE) == INPUT_TYPE_EDITABLE);
}

bool VisualScriptLists::is_output_port_editable() const {
	return ((flags & OUTPUT_EDITABLE) == OUTPUT_EDITABLE);
}

bool VisualScriptLists::is_output_port_name_editable() const {
	return ((flags & INPUT_NAME_EDITABLE) == INPUT_NAME_EDITABLE);
}

bool VisualScriptLists::is_output_port_type_editable() const {
	return ((flags & INPUT_TYPE_EDITABLE) == INPUT_TYPE_EDITABLE);
}

// for the inspector
bool VisualScriptLists::_set(const StringName &p_name, const Variant &p_value) {
	if (p_name == "input_count" && is_input_port_editable()) {
		int new_argc = p_value;
		int argc = inputports.size();
		if (argc == new_argc) {
			return true;
		}

		inputports.resize(new_argc);

		for (int i = argc; i < new_argc; i++) {
			inputports.write[i].name = "arg" + itos(i + 1);
			inputports.write[i].type = Variant::NIL;
		}
		ports_changed_notify();
		notify_property_list_changed();
		return true;
	}
	if (String(p_name).begins_with("input_") && is_input_port_editable()) {
		int idx = String(p_name).get_slicec('_', 1).get_slicec('/', 0).to_int() - 1;
		ERR_FAIL_INDEX_V(idx, inputports.size(), false);
		String what = String(p_name).get_slice("/", 1);
		if (what == "type") {
			Variant::Type new_type = Variant::Type(int(p_value));
			inputports.write[idx].type = new_type;
			ports_changed_notify();

			return true;
		}

		if (what == "name") {
			inputports.write[idx].name = p_value;
			ports_changed_notify();
			return true;
		}
	}

	if (p_name == "output_count" && is_output_port_editable()) {
		int new_argc = p_value;
		int argc = outputports.size();
		if (argc == new_argc) {
			return true;
		}

		outputports.resize(new_argc);

		for (int i = argc; i < new_argc; i++) {
			outputports.write[i].name = "arg" + itos(i + 1);
			outputports.write[i].type = Variant::NIL;
		}
		ports_changed_notify();
		notify_property_list_changed();
		return true;
	}
	if (String(p_name).begins_with("output_") && is_output_port_editable()) {
		int idx = String(p_name).get_slicec('_', 1).get_slicec('/', 0).to_int() - 1;
		ERR_FAIL_INDEX_V(idx, outputports.size(), false);
		String what = String(p_name).get_slice("/", 1);
		if (what == "type") {
			Variant::Type new_type = Variant::Type(int(p_value));
			outputports.write[idx].type = new_type;
			ports_changed_notify();

			return true;
		}

		if (what == "name") {
			outputports.write[idx].name = p_value;
			ports_changed_notify();
			return true;
		}
	}

	if (p_name == "sequenced/sequenced") {
		sequenced = p_value;
		ports_changed_notify();
		return true;
	}

	return false;
}

bool VisualScriptLists::_get(const StringName &p_name, Variant &r_ret) const {
	if (p_name == "input_count" && is_input_port_editable()) {
		r_ret = inputports.size();
		return true;
	}
	if (String(p_name).begins_with("input_") && is_input_port_editable()) {
		int idx = String(p_name).get_slicec('_', 1).get_slicec('/', 0).to_int() - 1;
		ERR_FAIL_INDEX_V(idx, inputports.size(), false);
		String what = String(p_name).get_slice("/", 1);
		if (what == "type") {
			r_ret = inputports[idx].type;
			return true;
		}
		if (what == "name") {
			r_ret = inputports[idx].name;
			return true;
		}
	}

	if (p_name == "output_count" && is_output_port_editable()) {
		r_ret = outputports.size();
		return true;
	}
	if (String(p_name).begins_with("output_") && is_output_port_editable()) {
		int idx = String(p_name).get_slicec('_', 1).get_slicec('/', 0).to_int() - 1;
		ERR_FAIL_INDEX_V(idx, outputports.size(), false);
		String what = String(p_name).get_slice("/", 1);
		if (what == "type") {
			r_ret = outputports[idx].type;
			return true;
		}
		if (what == "name") {
			r_ret = outputports[idx].name;
			return true;
		}
	}

	if (p_name == "sequenced/sequenced") {
		r_ret = sequenced;
		return true;
	}

	return false;
}

void VisualScriptLists::_get_property_list(List<PropertyInfo> *p_list) const {
	if (is_input_port_editable()) {
		p_list->push_back(PropertyInfo(Variant::INT, "input_count",
				PROPERTY_HINT_RANGE, "0,256"));
		String argt = "Any";
		for (int i = 1; i < Variant::VARIANT_MAX; i++) {
			argt += "," + Variant::get_type_name(Variant::Type(i));
		}

		for (int i = 0; i < inputports.size(); i++) {
			p_list->push_back(PropertyInfo(Variant::INT,
					"input_" + itos(i + 1) + "/type",
					PROPERTY_HINT_ENUM, argt));
			p_list->push_back(
					PropertyInfo(Variant::STRING, "input_" + itos(i + 1) + "/name"));
		}
	}

	if (is_output_port_editable()) {
		p_list->push_back(PropertyInfo(Variant::INT, "output_count",
				PROPERTY_HINT_RANGE, "0,256"));
		String argt = "Any";
		for (int i = 1; i < Variant::VARIANT_MAX; i++) {
			argt += "," + Variant::get_type_name(Variant::Type(i));
		}

		for (int i = 0; i < outputports.size(); i++) {
			p_list->push_back(PropertyInfo(Variant::INT,
					"output_" + itos(i + 1) + "/type",
					PROPERTY_HINT_ENUM, argt));
			p_list->push_back(
					PropertyInfo(Variant::STRING, "output_" + itos(i + 1) + "/name"));
		}
	}
	p_list->push_back(PropertyInfo(Variant::BOOL, "sequenced/sequenced"));
}

// input data port interaction
void VisualScriptLists::add_input_data_port(Variant::Type p_type,
		const String &p_name, int p_index) {
	if (!is_input_port_editable()) {
		return;
	}

	Port inp;
	inp.name = p_name;
	inp.type = p_type;
	if (p_index >= 0) {
		inputports.insert(p_index, inp);
	} else {
		inputports.push_back(inp);
	}

	ports_changed_notify();
	notify_property_list_changed();
}

void VisualScriptLists::set_input_data_port_type(int p_idx,
		Variant::Type p_type) {
	if (!is_input_port_type_editable()) {
		return;
	}

	ERR_FAIL_INDEX(p_idx, inputports.size());

	inputports.write[p_idx].type = p_type;
	ports_changed_notify();
	notify_property_list_changed();
}

void VisualScriptLists::set_input_data_port_name(int p_idx,
		const String &p_name) {
	if (!is_input_port_name_editable()) {
		return;
	}

	ERR_FAIL_INDEX(p_idx, inputports.size());

	inputports.write[p_idx].name = p_name;
	ports_changed_notify();
	notify_property_list_changed();
}

void VisualScriptLists::remove_input_data_port(int p_argidx) {
	if (!is_input_port_editable()) {
		return;
	}

	ERR_FAIL_INDEX(p_argidx, inputports.size());

	inputports.remove_at(p_argidx);

	ports_changed_notify();
	notify_property_list_changed();
}

// output data port interaction
void VisualScriptLists::add_output_data_port(Variant::Type p_type,
		const String &p_name,
		int p_index) {
	if (!is_output_port_editable()) {
		return;
	}

	Port out;
	out.name = p_name;
	out.type = p_type;
	if (p_index >= 0) {
		outputports.insert(p_index, out);
	} else {
		outputports.push_back(out);
	}

	ports_changed_notify();
	notify_property_list_changed();
}

void VisualScriptLists::set_output_data_port_type(int p_idx,
		Variant::Type p_type) {
	if (!is_output_port_type_editable()) {
		return;
	}

	ERR_FAIL_INDEX(p_idx, outputports.size());

	outputports.write[p_idx].type = p_type;
	ports_changed_notify();
	notify_property_list_changed();
}

void VisualScriptLists::set_output_data_port_name(int p_idx,
		const String &p_name) {
	if (!is_output_port_name_editable()) {
		return;
	}

	ERR_FAIL_INDEX(p_idx, outputports.size());

	outputports.write[p_idx].name = p_name;
	ports_changed_notify();
	notify_property_list_changed();
}

void VisualScriptLists::remove_output_data_port(int p_argidx) {
	if (!is_output_port_editable()) {
		return;
	}

	ERR_FAIL_INDEX(p_argidx, outputports.size());

	outputports.remove_at(p_argidx);

	ports_changed_notify();
	notify_property_list_changed();
}

// sequences
void VisualScriptLists::set_sequenced(bool p_enable) {
	if (sequenced == p_enable) {
		return;
	}
	sequenced = p_enable;
	ports_changed_notify();
}

bool VisualScriptLists::is_sequenced() const { return sequenced; }

void VisualScriptLists::reset_state() {
	inputports.clear();
	outputports.clear();
	sequenced = false;
	flags = 0;
}

VisualScriptLists::VisualScriptLists() {
	// initialize
	sequenced = false;
	flags = 0;
}

void VisualScriptLists::_bind_methods() {
	ClassDB::bind_method(D_METHOD("add_input_data_port", "type", "name", "index"),
			&VisualScriptLists::add_input_data_port);
	ClassDB::bind_method(D_METHOD("set_input_data_port_name", "index", "name"),
			&VisualScriptLists::set_input_data_port_name);
	ClassDB::bind_method(D_METHOD("set_input_data_port_type", "index", "type"),
			&VisualScriptLists::set_input_data_port_type);
	ClassDB::bind_method(D_METHOD("remove_input_data_port", "index"),
			&VisualScriptLists::remove_input_data_port);

	ClassDB::bind_method(
			D_METHOD("add_output_data_port", "type", "name", "index"),
			&VisualScriptLists::add_output_data_port);
	ClassDB::bind_method(D_METHOD("set_output_data_port_name", "index", "name"),
			&VisualScriptLists::set_output_data_port_name);
	ClassDB::bind_method(D_METHOD("set_output_data_port_type", "index", "type"),
			&VisualScriptLists::set_output_data_port_type);
	ClassDB::bind_method(D_METHOD("remove_output_data_port", "index"),
			&VisualScriptLists::remove_output_data_port);
}

//////////////////////////////////////////
//////////////COMPOSEARRAY////////////////
//////////////////////////////////////////

int VisualScriptComposeArray::get_output_sequence_port_count() const {
	if (sequenced) {
		return 1;
	}
	return 0;
}

bool VisualScriptComposeArray::has_input_sequence_port() const {
	return sequenced;
}

String
VisualScriptComposeArray::get_output_sequence_port_text(int p_port) const {
	return "";
}

int VisualScriptComposeArray::get_input_value_port_count() const {
	return inputports.size();
}

int VisualScriptComposeArray::get_output_value_port_count() const { return 1; }

PropertyInfo
VisualScriptComposeArray::get_input_value_port_info(int p_idx) const {
	ERR_FAIL_INDEX_V(p_idx, inputports.size(), PropertyInfo());

	PropertyInfo pi;
	pi.name = inputports[p_idx].name;
	pi.type = inputports[p_idx].type;
	return pi;
}

PropertyInfo
VisualScriptComposeArray::get_output_value_port_info(int p_idx) const {
	PropertyInfo pi;
	pi.name = "out";
	pi.type = Variant::ARRAY;
	return pi;
}

String VisualScriptComposeArray::get_caption() const {
	return RTR("Compose Array");
}

String VisualScriptComposeArray::get_text() const { return ""; }

class VisualScriptComposeArrayNode : public VisualScriptNodeInstance {
public:
	int input_count = 0;
	virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		if (input_count > 0) {
			Array arr;
			for (int i = 0; i < input_count; i++) {
				arr.push_back((*p_inputs[i]));
			}
			Variant va = Variant(arr);

			*p_outputs[0] = va;
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptComposeArray::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptComposeArrayNode *instance = memnew(VisualScriptComposeArrayNode);
	instance->input_count = inputports.size();
	return instance;
}

VisualScriptComposeArray::VisualScriptComposeArray() {
	// initialize stuff here
	sequenced = false;
	flags = INPUT_EDITABLE;
}

//////////////////////////////////////////
////////////////OPERATOR//////////////////
//////////////////////////////////////////

int VisualScriptOperator::get_output_sequence_port_count() const { return 0; }

bool VisualScriptOperator::has_input_sequence_port() const { return false; }

int VisualScriptOperator::get_input_value_port_count() const {
	return (op == Variant::OP_BIT_NEGATE || op == Variant::OP_NOT ||
				   op == Variant::OP_NEGATE || op == Variant::OP_POSITIVE)
			? 1
			: 2;
}

int VisualScriptOperator::get_output_value_port_count() const { return 1; }

String VisualScriptOperator::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptOperator::get_input_value_port_info(int p_idx) const {
	static const Variant::Type port_types[Variant::OP_MAX][2] = {
		{ Variant::NIL, Variant::NIL }, // OP_EQUAL,
		{ Variant::NIL, Variant::NIL }, // OP_NOT_EQUAL,
		{ Variant::NIL, Variant::NIL }, // OP_LESS,
		{ Variant::NIL, Variant::NIL }, // OP_LESS_EQUAL,
		{ Variant::NIL, Variant::NIL }, // OP_GREATER,
		{ Variant::NIL, Variant::NIL }, // OP_GREATER_EQUAL,
		// mathematic
		{ Variant::NIL, Variant::NIL }, // OP_ADD,
		{ Variant::NIL, Variant::NIL }, // OP_SUBTRACT,
		{ Variant::NIL, Variant::NIL }, // OP_MULTIPLY,
		{ Variant::NIL, Variant::NIL }, // OP_DIVIDE,
		{ Variant::NIL, Variant::NIL }, // OP_NEGATE,
		{ Variant::NIL, Variant::NIL }, // OP_POSITIVE,
		{ Variant::INT, Variant::INT }, // OP_MODULE,
		// bitwise
		{ Variant::INT, Variant::INT }, // OP_SHIFT_LEFT,
		{ Variant::INT, Variant::INT }, // OP_SHIFT_RIGHT,
		{ Variant::INT, Variant::INT }, // OP_BIT_AND,
		{ Variant::INT, Variant::INT }, // OP_BIT_OR,
		{ Variant::INT, Variant::INT }, // OP_BIT_XOR,
		{ Variant::INT, Variant::INT }, // OP_BIT_NEGATE,
		// logic
		{ Variant::BOOL, Variant::BOOL }, // OP_AND,
		{ Variant::BOOL, Variant::BOOL }, // OP_OR,
		{ Variant::BOOL, Variant::BOOL }, // OP_XOR,
		{ Variant::BOOL, Variant::BOOL }, // OP_NOT,
		// containment
		{ Variant::NIL, Variant::NIL } // OP_IN,
	};

	ERR_FAIL_INDEX_V(p_idx, 2, PropertyInfo());

	PropertyInfo pinfo;
	pinfo.name = p_idx == 0 ? "A" : "B";
	pinfo.type = port_types[op][p_idx];
	if (pinfo.type == Variant::NIL) {
		pinfo.type = typed;
	}
	return pinfo;
}

PropertyInfo VisualScriptOperator::get_output_value_port_info(int p_idx) const {
	static const Variant::Type port_types[Variant::OP_MAX] = {
		// comparison
		Variant::BOOL, // OP_EQUAL,
		Variant::BOOL, // OP_NOT_EQUAL,
		Variant::BOOL, // OP_LESS,
		Variant::BOOL, // OP_LESS_EQUAL,
		Variant::BOOL, // OP_GREATER,
		Variant::BOOL, // OP_GREATER_EQUAL,
		// mathematic
		Variant::NIL, // OP_ADD,
		Variant::NIL, // OP_SUBTRACT,
		Variant::NIL, // OP_MULTIPLY,
		Variant::NIL, // OP_DIVIDE,
		Variant::NIL, // OP_NEGATE,
		Variant::NIL, // OP_POSITIVE,
		Variant::INT, // OP_MODULE,
		// bitwise
		Variant::INT, // OP_SHIFT_LEFT,
		Variant::INT, // OP_SHIFT_RIGHT,
		Variant::INT, // OP_BIT_AND,
		Variant::INT, // OP_BIT_OR,
		Variant::INT, // OP_BIT_XOR,
		Variant::INT, // OP_BIT_NEGATE,
		// logic
		Variant::BOOL, // OP_AND,
		Variant::BOOL, // OP_OR,
		Variant::BOOL, // OP_XOR,
		Variant::BOOL, // OP_NOT,
		// containment
		Variant::BOOL // OP_IN,
	};

	PropertyInfo pinfo;
	pinfo.name = "";
	pinfo.type = port_types[op];
	if (pinfo.type == Variant::NIL) {
		pinfo.type = typed;
	}
	return pinfo;
}

String VisualScriptOperator::get_caption() const {
	switch (op) {
		// comparison
		case Variant::OP_EQUAL:
			return U"A = B";
		case Variant::OP_NOT_EQUAL:
			return U"A \u2260 B";
		case Variant::OP_LESS:
			return U"A < B";
		case Variant::OP_LESS_EQUAL:
			return U"A \u2264 B";
		case Variant::OP_GREATER:
			return U"A > B";
		case Variant::OP_GREATER_EQUAL:
			return U"A \u2265 B";

		// mathematic
		case Variant::OP_ADD:
			return U"A + B";
		case Variant::OP_SUBTRACT:
			return U"A - B";
		case Variant::OP_MULTIPLY:
			return U"A \u00D7 B";
		case Variant::OP_DIVIDE:
			return U"A \u00F7 B";
		case Variant::OP_NEGATE:
			return U"\u00AC A";
		case Variant::OP_POSITIVE:
			return U"+ A";
		case Variant::OP_MODULE:
			return U"A mod B";

		// bitwise
		case Variant::OP_SHIFT_LEFT:
			return U"A << B";
		case Variant::OP_SHIFT_RIGHT:
			return U"A >> B";
		case Variant::OP_BIT_AND:
			return U"A & B";
		case Variant::OP_BIT_OR:
			return U"A | B";
		case Variant::OP_BIT_XOR:
			return U"A ^ B";
		case Variant::OP_BIT_NEGATE:
			return U"~A";

		// logic
		case Variant::OP_AND:
			return U"A and B";
		case Variant::OP_OR:
			return U"A or B";
		case Variant::OP_XOR:
			return U"A xor B";
		case Variant::OP_NOT:
			return U"not A";
		case Variant::OP_IN:
			return U"A in B";

		default: {
			ERR_FAIL_V_MSG(U"Unknown node",
					U"Unknown node type encountered, caption not available.");
		}
	}
}

String VisualScriptOperator::get_operator_name(Variant::Operator p_op) {
	switch (p_op) {
		// comparison
		case Variant::OP_EQUAL:
			return "Are Equal";
		case Variant::OP_NOT_EQUAL:
			return "Are Not Equal";
		case Variant::OP_LESS:
			return "Less Than";
		case Variant::OP_LESS_EQUAL:
			return "Less Than or Equal";
		case Variant::OP_GREATER:
			return "Greater Than";
		case Variant::OP_GREATER_EQUAL:
			return "Greater Than or Equal";

		// mathematic
		case Variant::OP_ADD:
			return "Add";
		case Variant::OP_SUBTRACT:
			return "Subtract";
		case Variant::OP_MULTIPLY:
			return "Multiply";
		case Variant::OP_DIVIDE:
			return "Divide";
		case Variant::OP_NEGATE:
			return "Negate";
		case Variant::OP_POSITIVE:
			return "Positive";
		case Variant::OP_MODULE:
			return "Remainder";

		// bitwise
		case Variant::OP_SHIFT_LEFT:
			return "Bit Shift Left";
		case Variant::OP_SHIFT_RIGHT:
			return "Bit Shift Right";
		case Variant::OP_BIT_AND:
			return "Bit And";
		case Variant::OP_BIT_OR:
			return "Bit Or";
		case Variant::OP_BIT_XOR:
			return "Bit Xor";
		case Variant::OP_BIT_NEGATE:
			return "Bit Negate";

		// logic
		case Variant::OP_AND:
			return "And";
		case Variant::OP_OR:
			return "Or";
		case Variant::OP_XOR:
			return "Xor";
		case Variant::OP_NOT:
			return "Not";
		case Variant::OP_IN:
			return "In";

		default: {
			ERR_FAIL_INDEX_V(p_op, Variant::OP_MAX, "");
			return "Unknown Operator";
		}
	}
}

void VisualScriptOperator::set_operator(Variant::Operator p_op) {
	if (op == p_op) {
		return;
	}
	op = p_op;
	ports_changed_notify();
}

Variant::Operator VisualScriptOperator::get_operator() const { return op; }

void VisualScriptOperator::set_typed(Variant::Type p_op) {
	if (typed == p_op) {
		return;
	}

	typed = p_op;
	ports_changed_notify();
}

Variant::Type VisualScriptOperator::get_typed() const { return typed; }

void VisualScriptOperator::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_operator", "op"),
			&VisualScriptOperator::set_operator);
	ClassDB::bind_method(D_METHOD("get_operator"),
			&VisualScriptOperator::get_operator);

	ClassDB::bind_method(D_METHOD("set_typed", "type"),
			&VisualScriptOperator::set_typed);
	ClassDB::bind_method(D_METHOD("get_typed"), &VisualScriptOperator::get_typed);

	String types;
	for (int i = 0; i < Variant::OP_MAX; i++) {
		if (i > 0) {
			types += ",";
		}
		types += get_operator_name(static_cast<Variant::Operator>(i));
	}

	String argt = "Any";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	ADD_PROPERTY(
			PropertyInfo(Variant::INT, "operator", PROPERTY_HINT_ENUM, types),
			"set_operator", "get_operator");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt),
			"set_typed", "get_typed");
}

class VisualScriptNodeInstanceOperator : public VisualScriptNodeInstance {
public:
	bool unary = false;
	Variant::Operator op;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		bool valid;
		if (unary) {
			Variant::evaluate(op, *p_inputs[0], Variant(), *p_outputs[0], valid);
		} else {
			Variant::evaluate(op, *p_inputs[0], *p_inputs[1], *p_outputs[0], valid);
		}

		if (!valid) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			if (p_outputs[0]->get_type() == Variant::STRING) {
				r_error_str = *p_outputs[0];
			} else {
				if (unary) {
					r_error_str = String(Variant::get_operator_name(op)) + ": " +
							RTR("Invalid argument of type:") + " " +
							Variant::get_type_name(p_inputs[0]->get_type());
				} else {
					r_error_str =
							String(Variant::get_operator_name(op)) + ": " +
							RTR("Invalid arguments:") +
							" A: " + Variant::get_type_name(p_inputs[0]->get_type()) +
							", B: " + Variant::get_type_name(p_inputs[1]->get_type());
				}
			}
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptOperator::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceOperator *instance =
			memnew(VisualScriptNodeInstanceOperator);
	instance->unary = get_input_value_port_count() == 1;
	instance->op = op;
	return instance;
}

VisualScriptOperator::VisualScriptOperator() {
	op = Variant::OP_ADD;
	typed = Variant::NIL;
}

template <Variant::Operator OP>
static Ref<VisualScriptNode> create_op_node(const String &p_name) {
	Ref<VisualScriptOperator> node;
	node.instantiate();
	node->set_operator(OP);
	return node;
}

//////////////////////////////////////////
////////////////OPERATOR//////////////////
//////////////////////////////////////////

int VisualScriptSelect::get_output_sequence_port_count() const { return 0; }

bool VisualScriptSelect::has_input_sequence_port() const { return false; }

int VisualScriptSelect::get_input_value_port_count() const { return 3; }

int VisualScriptSelect::get_output_value_port_count() const { return 1; }

String VisualScriptSelect::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptSelect::get_input_value_port_info(int p_idx) const {
	if (p_idx == 0) {
		return PropertyInfo(Variant::BOOL, "cond");
	} else if (p_idx == 1) {
		return PropertyInfo(typed, "a");
	} else {
		return PropertyInfo(typed, "b");
	}
}

PropertyInfo VisualScriptSelect::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(typed, "out");
}

String VisualScriptSelect::get_caption() const { return RTR("Select"); }

String VisualScriptSelect::get_text() const { return RTR("a if cond, else b"); }

void VisualScriptSelect::set_typed(Variant::Type p_op) {
	if (typed == p_op) {
		return;
	}

	typed = p_op;
	ports_changed_notify();
}

Variant::Type VisualScriptSelect::get_typed() const { return typed; }

void VisualScriptSelect::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_typed", "type"),
			&VisualScriptSelect::set_typed);
	ClassDB::bind_method(D_METHOD("get_typed"), &VisualScriptSelect::get_typed);

	String argt = "Any";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt),
			"set_typed", "get_typed");
}

class VisualScriptNodeInstanceSelect : public VisualScriptNodeInstance {
public:
	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		bool cond = *p_inputs[0];
		if (cond) {
			*p_outputs[0] = *p_inputs[1];
		} else {
			*p_outputs[0] = *p_inputs[2];
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptSelect::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceSelect *instance =
			memnew(VisualScriptNodeInstanceSelect);
	return instance;
}

VisualScriptSelect::VisualScriptSelect() { typed = Variant::NIL; }

//////////////////////////////////////////
////////////////VARIABLE GET//////////////////
//////////////////////////////////////////

int VisualScriptVariableGet::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptVariableGet::has_input_sequence_port() const { return false; }

int VisualScriptVariableGet::get_input_value_port_count() const { return 0; }

int VisualScriptVariableGet::get_output_value_port_count() const { return 1; }

String
VisualScriptVariableGet::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptVariableGet::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptVariableGet::get_output_value_port_info(int p_idx) const {
	PropertyInfo pinfo;
	pinfo.name = "value";
	if (get_visual_script().is_valid() &&
			get_visual_script()->has_variable(variable)) {
		PropertyInfo vinfo = get_visual_script()->get_variable_info(variable);
		pinfo.type = vinfo.type;
		pinfo.hint = vinfo.hint;
		pinfo.hint_string = vinfo.hint_string;
	}
	return pinfo;
}

String VisualScriptVariableGet::get_caption() const {
	return vformat(RTR("Get %s"), variable);
}

void VisualScriptVariableGet::set_variable(StringName p_variable) {
	if (variable == p_variable) {
		return;
	}
	variable = p_variable;
	ports_changed_notify();
}

StringName VisualScriptVariableGet::get_variable() const { return variable; }

void VisualScriptVariableGet::_validate_property(
		PropertyInfo &p_property) const {
	if (p_property.name == "var_name" && get_visual_script().is_valid()) {
		Ref<VisualScript> vs = get_visual_script();
		List<StringName> vars;
		vs->get_variable_list(&vars);

		String vhint;
		for (const StringName &E : vars) {
			if (!vhint.is_empty()) {
				vhint += ",";
			}

			vhint += E.operator String();
		}

		p_property.hint = PROPERTY_HINT_ENUM;
		p_property.hint_string = vhint;
	}
}

void VisualScriptVariableGet::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_variable", "name"),
			&VisualScriptVariableGet::set_variable);
	ClassDB::bind_method(D_METHOD("get_variable"),
			&VisualScriptVariableGet::get_variable);

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "var_name"), "set_variable",
			"get_variable");
}

class VisualScriptNodeInstanceVariableGet : public VisualScriptNodeInstance {
public:
	VisualScriptVariableGet *node = nullptr;
	VisualScriptInstance *instance = nullptr;
	StringName variable;

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		if (!instance->get_variable(variable, p_outputs[0])) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str = RTR("VariableGet not found in script:") + " '" +
					String(variable) + "'";
			return 0;
		}
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptVariableGet::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceVariableGet *instance =
			memnew(VisualScriptNodeInstanceVariableGet);
	instance->node = this;
	instance->instance = p_instance;
	instance->variable = variable;
	return instance;
}

VisualScriptVariableGet::VisualScriptVariableGet() {}

//////////////////////////////////////////
////////////////VARIABLE SET//////////////////
//////////////////////////////////////////

int VisualScriptVariableSet::get_output_sequence_port_count() const {
	return 1;
}

bool VisualScriptVariableSet::has_input_sequence_port() const { return true; }

int VisualScriptVariableSet::get_input_value_port_count() const { return 1; }

int VisualScriptVariableSet::get_output_value_port_count() const { return 0; }

String
VisualScriptVariableSet::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptVariableSet::get_input_value_port_info(int p_idx) const {
	PropertyInfo pinfo;
	pinfo.name = "set";
	if (get_visual_script().is_valid() &&
			get_visual_script()->has_variable(variable)) {
		PropertyInfo vinfo = get_visual_script()->get_variable_info(variable);
		pinfo.type = vinfo.type;
		pinfo.hint = vinfo.hint;
		pinfo.hint_string = vinfo.hint_string;
	}
	return pinfo;
}

PropertyInfo
VisualScriptVariableSet::get_output_value_port_info(int p_idx) const {
	return PropertyInfo();
}

String VisualScriptVariableSet::get_caption() const {
	return vformat(RTR("Set %s"), variable);
}

void VisualScriptVariableSet::set_variable(StringName p_variable) {
	if (variable == p_variable) {
		return;
	}
	variable = p_variable;
	ports_changed_notify();
}

StringName VisualScriptVariableSet::get_variable() const { return variable; }

void VisualScriptVariableSet::_validate_property(
		PropertyInfo &p_property) const {
	if (p_property.name == "var_name" && get_visual_script().is_valid()) {
		Ref<VisualScript> vs = get_visual_script();
		List<StringName> vars;
		vs->get_variable_list(&vars);

		String vhint;
		for (const StringName &E : vars) {
			if (!vhint.is_empty()) {
				vhint += ",";
			}

			vhint += E.operator String();
		}

		p_property.hint = PROPERTY_HINT_ENUM;
		p_property.hint_string = vhint;
	}
}

void VisualScriptVariableSet::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_variable", "name"),
			&VisualScriptVariableSet::set_variable);
	ClassDB::bind_method(D_METHOD("get_variable"),
			&VisualScriptVariableSet::get_variable);

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "var_name"), "set_variable",
			"get_variable");
}

class VisualScriptNodeInstanceVariableSet : public VisualScriptNodeInstance {
public:
	VisualScriptVariableSet *node = nullptr;
	VisualScriptInstance *instance = nullptr;
	StringName variable;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		if (!instance->set_variable(variable, *p_inputs[0])) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str = RTR("VariableSet not found in script:") + " '" +
					String(variable) + "'";
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptVariableSet::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceVariableSet *instance =
			memnew(VisualScriptNodeInstanceVariableSet);
	instance->node = this;
	instance->instance = p_instance;
	instance->variable = variable;
	return instance;
}

VisualScriptVariableSet::VisualScriptVariableSet() {}

//////////////////////////////////////////
////////////////CONSTANT//////////////////
//////////////////////////////////////////

int VisualScriptConstant::get_output_sequence_port_count() const { return 0; }

bool VisualScriptConstant::has_input_sequence_port() const { return false; }

int VisualScriptConstant::get_input_value_port_count() const { return 0; }

int VisualScriptConstant::get_output_value_port_count() const { return 1; }

String VisualScriptConstant::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptConstant::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo VisualScriptConstant::get_output_value_port_info(int p_idx) const {
	PropertyInfo pinfo;
	pinfo.name = String(value);
	pinfo.type = type;
	return pinfo;
}

String VisualScriptConstant::get_caption() const { return RTR("Constant"); }

void VisualScriptConstant::set_constant_type(Variant::Type p_type) {
	if (type == p_type) {
		return;
	}

	type = p_type;
	Callable::CallError ce;
	Variant::construct(type, value, nullptr, 0, ce);
	ports_changed_notify();
	notify_property_list_changed();
}

Variant::Type VisualScriptConstant::get_constant_type() const { return type; }

void VisualScriptConstant::set_constant_value(Variant p_value) {
	if (value == p_value) {
		return;
	}

	value = p_value;
	ports_changed_notify();
}

Variant VisualScriptConstant::get_constant_value() const { return value; }

void VisualScriptConstant::_validate_property(PropertyInfo &p_property) const {
	if (p_property.name == "value") {
		p_property.type = type;
		if (type == Variant::NIL) {
			p_property.usage = PROPERTY_USAGE_NONE; // do not save if nil
		}
	}
}

void VisualScriptConstant::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_constant_type", "type"),
			&VisualScriptConstant::set_constant_type);
	ClassDB::bind_method(D_METHOD("get_constant_type"),
			&VisualScriptConstant::get_constant_type);

	ClassDB::bind_method(D_METHOD("set_constant_value", "value"),
			&VisualScriptConstant::set_constant_value);
	ClassDB::bind_method(D_METHOD("get_constant_value"),
			&VisualScriptConstant::get_constant_value);

	String argt = "Null";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt),
			"set_constant_type", "get_constant_type");
	ADD_PROPERTY(
			PropertyInfo(Variant::NIL, "value", PROPERTY_HINT_NONE, "",
					PROPERTY_USAGE_NIL_IS_VARIANT | PROPERTY_USAGE_DEFAULT),
			"set_constant_value", "get_constant_value");
}

class VisualScriptNodeInstanceConstant : public VisualScriptNodeInstance {
public:
	Variant constant;
	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = constant;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptConstant::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceConstant *instance =
			memnew(VisualScriptNodeInstanceConstant);
	instance->constant = value;
	return instance;
}

VisualScriptConstant::VisualScriptConstant() { type = Variant::NIL; }

//////////////////////////////////////////
////////////////PRELOAD//////////////////
//////////////////////////////////////////

int VisualScriptPreload::get_output_sequence_port_count() const { return 0; }

bool VisualScriptPreload::has_input_sequence_port() const { return false; }

int VisualScriptPreload::get_input_value_port_count() const { return 0; }

int VisualScriptPreload::get_output_value_port_count() const { return 1; }

String VisualScriptPreload::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptPreload::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo VisualScriptPreload::get_output_value_port_info(int p_idx) const {
	PropertyInfo pinfo;
	pinfo.type = Variant::OBJECT;
	if (preload.is_valid()) {
		pinfo.hint = PROPERTY_HINT_RESOURCE_TYPE;
		pinfo.hint_string = preload->get_class();
		if (preload->get_path().is_resource_file()) {
			pinfo.name = preload->get_path();
		} else if (!preload->get_name().is_empty()) {
			pinfo.name = preload->get_name();
		} else {
			pinfo.name = preload->get_class();
		}
	} else {
		pinfo.name = "<empty>";
	}

	return pinfo;
}

String VisualScriptPreload::get_caption() const { return RTR("Preload"); }

void VisualScriptPreload::set_preload(const Ref<Resource> &p_preload) {
	if (preload == p_preload) {
		return;
	}

	preload = p_preload;
	ports_changed_notify();
}

Ref<Resource> VisualScriptPreload::get_preload() const { return preload; }

void VisualScriptPreload::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_preload", "resource"),
			&VisualScriptPreload::set_preload);
	ClassDB::bind_method(D_METHOD("get_preload"),
			&VisualScriptPreload::get_preload);

	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "resource",
						 PROPERTY_HINT_RESOURCE_TYPE, "Resource"),
			"set_preload", "get_preload");
}

class VisualScriptNodeInstancePreload : public VisualScriptNodeInstance {
public:
	Ref<Resource> preload;
	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = preload;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptPreload::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstancePreload *instance =
			memnew(VisualScriptNodeInstancePreload);
	instance->preload = preload;
	return instance;
}

VisualScriptPreload::VisualScriptPreload() {}

//////////////////////////////////////////
////////////////INDEX////////////////////
//////////////////////////////////////////

int VisualScriptIndexGet::get_output_sequence_port_count() const { return 0; }

bool VisualScriptIndexGet::has_input_sequence_port() const { return false; }

int VisualScriptIndexGet::get_input_value_port_count() const { return 2; }

int VisualScriptIndexGet::get_output_value_port_count() const { return 1; }

String VisualScriptIndexGet::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptIndexGet::get_input_value_port_info(int p_idx) const {
	if (p_idx == 0) {
		return PropertyInfo(Variant::NIL, "base");
	} else {
		return PropertyInfo(Variant::NIL, "index");
	}
}

PropertyInfo VisualScriptIndexGet::get_output_value_port_info(int p_idx) const {
	return PropertyInfo();
}

String VisualScriptIndexGet::get_caption() const { return RTR("Get Index"); }

class VisualScriptNodeInstanceIndexGet : public VisualScriptNodeInstance {
public:
	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		bool valid;
		*p_outputs[0] = p_inputs[0]->get(*p_inputs[1], &valid);

		if (!valid) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str = "Invalid get: " + p_inputs[0]->get_construct_string();
		}
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptIndexGet::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceIndexGet *instance =
			memnew(VisualScriptNodeInstanceIndexGet);
	return instance;
}

VisualScriptIndexGet::VisualScriptIndexGet() {}

//////////////////////////////////////////
////////////////INDEXSET//////////////////
//////////////////////////////////////////

int VisualScriptIndexSet::get_output_sequence_port_count() const { return 1; }

bool VisualScriptIndexSet::has_input_sequence_port() const { return true; }

int VisualScriptIndexSet::get_input_value_port_count() const { return 3; }

int VisualScriptIndexSet::get_output_value_port_count() const { return 0; }

String VisualScriptIndexSet::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptIndexSet::get_input_value_port_info(int p_idx) const {
	if (p_idx == 0) {
		return PropertyInfo(Variant::NIL, "base");
	} else if (p_idx == 1) {
		return PropertyInfo(Variant::NIL, "index");

	} else {
		return PropertyInfo(Variant::NIL, "value");
	}
}

PropertyInfo VisualScriptIndexSet::get_output_value_port_info(int p_idx) const {
	return PropertyInfo();
}

String VisualScriptIndexSet::get_caption() const { return RTR("Set Index"); }

class VisualScriptNodeInstanceIndexSet : public VisualScriptNodeInstance {
public:
	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		bool valid;
		((Variant *)p_inputs[0])->set(*p_inputs[1], *p_inputs[2], &valid);

		if (!valid) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str = "Invalid set: " + p_inputs[1]->get_construct_string();
		}
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptIndexSet::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceIndexSet *instance =
			memnew(VisualScriptNodeInstanceIndexSet);
	return instance;
}

VisualScriptIndexSet::VisualScriptIndexSet() {}

//////////////////////////////////////////
////////////////GLOBALCONSTANT///////////
//////////////////////////////////////////

int VisualScriptGlobalConstant::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptGlobalConstant::has_input_sequence_port() const {
	return false;
}

int VisualScriptGlobalConstant::get_input_value_port_count() const { return 0; }

int VisualScriptGlobalConstant::get_output_value_port_count() const {
	return 1;
}

String
VisualScriptGlobalConstant::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptGlobalConstant::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptGlobalConstant::get_output_value_port_info(int p_idx) const {
	String global_constant_name = CoreConstants::get_global_constant_name(index);
	return PropertyInfo(Variant::INT, global_constant_name);
}

String VisualScriptGlobalConstant::get_caption() const {
	return RTR("Global Constant");
}

void VisualScriptGlobalConstant::set_global_constant(int p_which) {
	index = p_which;
	notify_property_list_changed();
	ports_changed_notify();
}

int VisualScriptGlobalConstant::get_global_constant() { return index; }

class VisualScriptNodeInstanceGlobalConstant : public VisualScriptNodeInstance {
public:
	int index = 0;

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = CoreConstants::get_global_constant_value(index);
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptGlobalConstant::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceGlobalConstant *instance =
			memnew(VisualScriptNodeInstanceGlobalConstant);
	instance->index = index;
	return instance;
}

void VisualScriptGlobalConstant::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_global_constant", "index"),
			&VisualScriptGlobalConstant::set_global_constant);
	ClassDB::bind_method(D_METHOD("get_global_constant"),
			&VisualScriptGlobalConstant::get_global_constant);

	String cc;

	for (int i = 0; i < CoreConstants::get_global_constant_count(); i++) {
		if (i > 0) {
			cc += ",";
		}
		cc += CoreConstants::get_global_constant_name(i);
	}
	ADD_PROPERTY(PropertyInfo(Variant::INT, "constant", PROPERTY_HINT_ENUM, cc),
			"set_global_constant", "get_global_constant");
}

VisualScriptGlobalConstant::VisualScriptGlobalConstant() { index = 0; }

//////////////////////////////////////////
////////////////CLASSCONSTANT///////////
//////////////////////////////////////////

int VisualScriptClassConstant::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptClassConstant::has_input_sequence_port() const {
	return false;
}

int VisualScriptClassConstant::get_input_value_port_count() const { return 0; }

int VisualScriptClassConstant::get_output_value_port_count() const { return 1; }

String
VisualScriptClassConstant::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptClassConstant::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptClassConstant::get_output_value_port_info(int p_idx) const {
	if (name == "") {
		return PropertyInfo(Variant::INT, String(base_type));
	} else {
		return PropertyInfo(Variant::INT, String(base_type) + "." + String(name));
	}
}

String VisualScriptClassConstant::get_caption() const {
	return RTR("Class Constant");
}

void VisualScriptClassConstant::set_class_constant(const StringName &p_which) {
	name = p_which;
	notify_property_list_changed();
	ports_changed_notify();
}

StringName VisualScriptClassConstant::get_class_constant() { return name; }

void VisualScriptClassConstant::set_base_type(const StringName &p_which) {
	base_type = p_which;
	List<String> constants;
	ClassDB::get_integer_constant_list(base_type, &constants, true);
	if (constants.size() > 0) {
		bool found_name = false;
		for (const String &E : constants) {
			if (E == name) {
				found_name = true;
				break;
			}
		}
		if (!found_name) {
			name = constants[0];
		}
	} else {
		name = "";
	}
	notify_property_list_changed();
	ports_changed_notify();
}

StringName VisualScriptClassConstant::get_base_type() { return base_type; }

class VisualScriptNodeInstanceClassConstant : public VisualScriptNodeInstance {
public:
	int value = 0;
	bool valid = false;

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		if (!valid) {
			r_error_str = "Invalid constant name, pick a valid class constant.";
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
		}

		*p_outputs[0] = value;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptClassConstant::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceClassConstant *instance =
			memnew(VisualScriptNodeInstanceClassConstant);
	instance->value =
			ClassDB::get_integer_constant(base_type, name, &instance->valid);
	return instance;
}

void VisualScriptClassConstant::_validate_property(
		PropertyInfo &p_property) const {
	if (p_property.name == "constant") {
		List<String> constants;
		ClassDB::get_integer_constant_list(base_type, &constants, true);

		p_property.hint_string = "";
		for (const String &E : constants) {
			if (!p_property.hint_string.is_empty()) {
				p_property.hint_string += ",";
			}
			p_property.hint_string += E;
		}
	}
}

void VisualScriptClassConstant::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_class_constant", "name"),
			&VisualScriptClassConstant::set_class_constant);
	ClassDB::bind_method(D_METHOD("get_class_constant"),
			&VisualScriptClassConstant::get_class_constant);

	ClassDB::bind_method(D_METHOD("set_base_type", "name"),
			&VisualScriptClassConstant::set_base_type);
	ClassDB::bind_method(D_METHOD("get_base_type"),
			&VisualScriptClassConstant::get_base_type);

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "base_type",
						 PROPERTY_HINT_TYPE_STRING, "Object"),
			"set_base_type", "get_base_type");
	ADD_PROPERTY(
			PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, ""),
			"set_class_constant", "get_class_constant");
}

VisualScriptClassConstant::VisualScriptClassConstant() { base_type = "Object"; }

//////////////////////////////////////////
////////////////BASICTYPECONSTANT///////////
//////////////////////////////////////////

int VisualScriptBasicTypeConstant::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptBasicTypeConstant::has_input_sequence_port() const {
	return false;
}

int VisualScriptBasicTypeConstant::get_input_value_port_count() const {
	return 0;
}

int VisualScriptBasicTypeConstant::get_output_value_port_count() const {
	return 1;
}

String
VisualScriptBasicTypeConstant::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptBasicTypeConstant::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptBasicTypeConstant::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(type, "value");
}

String VisualScriptBasicTypeConstant::get_caption() const {
	return RTR("Basic Constant");
}

String VisualScriptBasicTypeConstant::get_text() const {
	if (name == "") {
		return Variant::get_type_name(type);
	} else {
		return Variant::get_type_name(type) + "." + String(name);
	}
}

void VisualScriptBasicTypeConstant::set_basic_type_constant(
		const StringName &p_which) {
	name = p_which;
	notify_property_list_changed();
	ports_changed_notify();
}

StringName VisualScriptBasicTypeConstant::get_basic_type_constant() const {
	return name;
}

void VisualScriptBasicTypeConstant::set_basic_type(Variant::Type p_which) {
	type = p_which;

	List<StringName> constants;
	Variant::get_constants_for_type(type, &constants);
	if (constants.size() > 0) {
		bool found_name = false;
		for (const StringName &E : constants) {
			if (E == name) {
				found_name = true;
				break;
			}
		}
		if (!found_name) {
			name = constants[0];
		}
	} else {
		name = "";
	}
	notify_property_list_changed();
	ports_changed_notify();
}

Variant::Type VisualScriptBasicTypeConstant::get_basic_type() const {
	return type;
}

class VisualScriptNodeInstanceBasicTypeConstant
		: public VisualScriptNodeInstance {
public:
	Variant value;
	bool valid = false;

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		if (!valid) {
			r_error_str = "Invalid constant name, pick a valid basic type constant.";
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
		}

		*p_outputs[0] = value;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptBasicTypeConstant::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceBasicTypeConstant *instance =
			memnew(VisualScriptNodeInstanceBasicTypeConstant);
	instance->value = Variant::get_constant_value(type, name, &instance->valid);
	return instance;
}

void VisualScriptBasicTypeConstant::_validate_property(
		PropertyInfo &p_property) const {
	if (p_property.name == "constant") {
		List<StringName> constants;
		Variant::get_constants_for_type(type, &constants);

		if (constants.size() == 0) {
			p_property.usage = PROPERTY_USAGE_NONE;
			return;
		}
		p_property.hint_string = "";
		for (const StringName &E : constants) {
			if (!p_property.hint_string.is_empty()) {
				p_property.hint_string += ",";
			}
			p_property.hint_string += String(E);
		}
	}
}

void VisualScriptBasicTypeConstant::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_basic_type", "name"),
			&VisualScriptBasicTypeConstant::set_basic_type);
	ClassDB::bind_method(D_METHOD("get_basic_type"),
			&VisualScriptBasicTypeConstant::get_basic_type);

	ClassDB::bind_method(D_METHOD("set_basic_type_constant", "name"),
			&VisualScriptBasicTypeConstant::set_basic_type_constant);
	ClassDB::bind_method(D_METHOD("get_basic_type_constant"),
			&VisualScriptBasicTypeConstant::get_basic_type_constant);

	String argt = "Null";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	ADD_PROPERTY(
			PropertyInfo(Variant::INT, "basic_type", PROPERTY_HINT_ENUM, argt),
			"set_basic_type", "get_basic_type");
	ADD_PROPERTY(
			PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, ""),
			"set_basic_type_constant", "get_basic_type_constant");
}

VisualScriptBasicTypeConstant::VisualScriptBasicTypeConstant() {
	type = Variant::NIL;
}

//////////////////////////////////////////
////////////////MATHCONSTANT///////////
//////////////////////////////////////////

const char *VisualScriptMathConstant::const_name[MATH_CONSTANT_MAX] = {
	"One", "PI", "PI/2", "TAU", "E", "Sqrt2", "INF", "NAN"
};

double VisualScriptMathConstant::const_value[MATH_CONSTANT_MAX] = {
	1.0,
	Math_PI,
	Math_PI * 0.5,
	Math_TAU,
	2.71828182845904523536,
	Math::sqrt(2.0),
	INFINITY,
	NAN
};

int VisualScriptMathConstant::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptMathConstant::has_input_sequence_port() const { return false; }

int VisualScriptMathConstant::get_input_value_port_count() const { return 0; }

int VisualScriptMathConstant::get_output_value_port_count() const { return 1; }

String
VisualScriptMathConstant::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptMathConstant::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptMathConstant::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(Variant::FLOAT, const_name[constant]);
}

String VisualScriptMathConstant::get_caption() const {
	return RTR("Math Constant");
}

void VisualScriptMathConstant::set_math_constant(MathConstant p_which) {
	constant = p_which;
	notify_property_list_changed();
	ports_changed_notify();
}

VisualScriptMathConstant::MathConstant
VisualScriptMathConstant::get_math_constant() {
	return constant;
}

class VisualScriptNodeInstanceMathConstant : public VisualScriptNodeInstance {
public:
	float value = 0.0f;

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = value;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptMathConstant::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceMathConstant *instance =
			memnew(VisualScriptNodeInstanceMathConstant);
	instance->value = const_value[constant];
	return instance;
}

void VisualScriptMathConstant::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_math_constant", "which"),
			&VisualScriptMathConstant::set_math_constant);
	ClassDB::bind_method(D_METHOD("get_math_constant"),
			&VisualScriptMathConstant::get_math_constant);

	String cc;

	for (int i = 0; i < MATH_CONSTANT_MAX; i++) {
		if (i > 0) {
			cc += ",";
		}
		cc += const_name[i];
	}
	ADD_PROPERTY(PropertyInfo(Variant::INT, "constant", PROPERTY_HINT_ENUM, cc),
			"set_math_constant", "get_math_constant");

	BIND_ENUM_CONSTANT(MATH_CONSTANT_ONE);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_PI);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_HALF_PI);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_TAU);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_E);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_SQRT2);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_INF);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_NAN);
	BIND_ENUM_CONSTANT(MATH_CONSTANT_MAX);
}

VisualScriptMathConstant::VisualScriptMathConstant() {
	constant = MATH_CONSTANT_ONE;
}

//////////////////////////////////////////
////////////////ENGINESINGLETON///////////
//////////////////////////////////////////

int VisualScriptEngineSingleton::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptEngineSingleton::has_input_sequence_port() const {
	return false;
}

int VisualScriptEngineSingleton::get_input_value_port_count() const {
	return 0;
}

int VisualScriptEngineSingleton::get_output_value_port_count() const {
	return 1;
}

String
VisualScriptEngineSingleton::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptEngineSingleton::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptEngineSingleton::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(Variant::OBJECT, singleton);
}

String VisualScriptEngineSingleton::get_caption() const {
	return RTR("Get Engine Singleton");
}

void VisualScriptEngineSingleton::set_singleton(const String &p_string) {
	singleton = p_string;

	notify_property_list_changed();
	ports_changed_notify();
}

String VisualScriptEngineSingleton::get_singleton() { return singleton; }

class VisualScriptNodeInstanceEngineSingleton
		: public VisualScriptNodeInstance {
public:
	Object *singleton = nullptr;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = singleton;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptEngineSingleton::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceEngineSingleton *instance =
			memnew(VisualScriptNodeInstanceEngineSingleton);
	instance->singleton =
			Engine::get_singleton()->get_singleton_object(singleton);
	return instance;
}

VisualScriptEngineSingleton::TypeGuess
VisualScriptEngineSingleton::guess_output_type(TypeGuess *p_inputs,
		int p_output) const {
	Object *obj = Engine::get_singleton()->get_singleton_object(singleton);
	TypeGuess tg;
	tg.type = Variant::OBJECT;
	if (obj) {
		tg.gdclass = obj->get_class();
		tg.script = obj->get_script();
	}

	return tg;
}

void VisualScriptEngineSingleton::_validate_property(
		PropertyInfo &p_property) const {
	String cc;

	List<Engine::Singleton> singletons;

	Engine::get_singleton()->get_singletons(&singletons);

	for (const Engine::Singleton &E : singletons) {
		if (E.name == "VS" || E.name == "PS" || E.name == "PS2D" ||
				E.name == "AS" || E.name == "TS" || E.name == "SS" ||
				E.name == "SS2D") {
			continue; // skip these, too simple named
		}

		if (!cc.is_empty()) {
			cc += ",";
		}
		cc += E.name;
	}

	p_property.hint = PROPERTY_HINT_ENUM;
	p_property.hint_string = cc;
}

void VisualScriptEngineSingleton::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_singleton", "name"),
			&VisualScriptEngineSingleton::set_singleton);
	ClassDB::bind_method(D_METHOD("get_singleton"),
			&VisualScriptEngineSingleton::get_singleton);

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant"), "set_singleton",
			"get_singleton");
}

VisualScriptEngineSingleton::VisualScriptEngineSingleton() {
	singleton = String();
}

//////////////////////////////////////////
////////////////GETNODE///////////
//////////////////////////////////////////

int VisualScriptSceneNode::get_output_sequence_port_count() const { return 0; }

bool VisualScriptSceneNode::has_input_sequence_port() const { return false; }

int VisualScriptSceneNode::get_input_value_port_count() const { return 0; }

int VisualScriptSceneNode::get_output_value_port_count() const { return 1; }

String VisualScriptSceneNode::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptSceneNode::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptSceneNode::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(Variant::OBJECT, path.simplified());
}

String VisualScriptSceneNode::get_caption() const {
	return RTR("Get Scene Node");
}

void VisualScriptSceneNode::set_node_path(const NodePath &p_path) {
	path = p_path;
	notify_property_list_changed();
	ports_changed_notify();
}

NodePath VisualScriptSceneNode::get_node_path() { return path; }

class VisualScriptNodeInstanceSceneNode : public VisualScriptNodeInstance {
public:
	VisualScriptSceneNode *node = nullptr;
	VisualScriptInstance *instance = nullptr;
	NodePath path;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		Node *step_node_node = Object::cast_to<Node>(instance->get_owner_ptr());
		if (!step_node_node) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str = "Base object is not a Node!";
			return 0;
		}

		Node *another = step_node_node->get_node(path);
		if (!another) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str = "Path does not lead Node!";
			return 0;
		}

		*p_outputs[0] = another;

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptSceneNode::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceSceneNode *instance =
			memnew(VisualScriptNodeInstanceSceneNode);
	instance->node = this;
	instance->instance = p_instance;
	instance->path = path;
	return instance;
}

#ifdef TOOLS_ENABLED

static Node *_find_script_node(Node *p_edited_scene, Node *p_current_node,
		const Ref<Script> &script) {
	if (p_edited_scene != p_current_node &&
			p_current_node->get_owner() != p_edited_scene) {
		return nullptr;
	}

	Ref<Script> scr = p_current_node->get_script();

	if (scr.is_valid() && scr == script) {
		return p_current_node;
	}

	for (int i = 0; i < p_current_node->get_child_count(); i++) {
		Node *n =
				_find_script_node(p_edited_scene, p_current_node->get_child(i), script);
		if (n) {
			return n;
		}
	}

	return nullptr;
}

#endif

VisualScriptSceneNode::TypeGuess
VisualScriptSceneNode::guess_output_type(TypeGuess *p_inputs,
		int p_output) const {
	VisualScriptSceneNode::TypeGuess tg;
	tg.type = Variant::OBJECT;
	tg.gdclass = SNAME("Node");

#ifdef TOOLS_ENABLED
	Ref<Script> guess_script = get_visual_script();
	if (!guess_script.is_valid()) {
		return tg;
	}

	MainLoop *main_loop = OS::get_singleton()->get_main_loop();
	SceneTree *scene_tree = Object::cast_to<SceneTree>(main_loop);

	if (!scene_tree) {
		return tg;
	}

	Node *edited_scene = scene_tree->get_edited_scene_root();

	if (!edited_scene) {
		return tg;
	}

	Node *script_node = _find_script_node(edited_scene, edited_scene, guess_script);

	if (!script_node) {
		return tg;
	}

	Node *another = script_node->get_node(path);

	if (another) {
		tg.gdclass = another->get_class();
		tg.script = another->get_script();
	}
#endif
	return tg;
}

void VisualScriptSceneNode::_validate_property(PropertyInfo &p_property) const {
#ifdef TOOLS_ENABLED
	if (p_property.name == "node_path") {
		Ref<Script> validate_script = get_visual_script();
		if (!validate_script.is_valid()) {
			return;
		}

		MainLoop *main_loop = OS::get_singleton()->get_main_loop();
		SceneTree *scene_tree = Object::cast_to<SceneTree>(main_loop);

		if (!scene_tree) {
			return;
		}

		Node *edited_scene = scene_tree->get_edited_scene_root();

		if (!edited_scene) {
			return;
		}

		Node *script_node = _find_script_node(edited_scene, edited_scene, validate_script);

		if (!script_node) {
			return;
		}

		p_property.hint_string = script_node->get_path();
	}
#endif
}

void VisualScriptSceneNode::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_node_path", "path"),
			&VisualScriptSceneNode::set_node_path);
	ClassDB::bind_method(D_METHOD("get_node_path"),
			&VisualScriptSceneNode::get_node_path);

	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "node_path",
						 PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),
			"set_node_path", "get_node_path");
}

VisualScriptSceneNode::VisualScriptSceneNode() { path = String("."); }

//////////////////////////////////////////
////////////////SceneTree///////////
//////////////////////////////////////////

int VisualScriptSceneTree::get_output_sequence_port_count() const { return 0; }

bool VisualScriptSceneTree::has_input_sequence_port() const { return false; }

int VisualScriptSceneTree::get_input_value_port_count() const { return 0; }

int VisualScriptSceneTree::get_output_value_port_count() const { return 1; }

String VisualScriptSceneTree::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptSceneTree::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptSceneTree::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(Variant::OBJECT, "Scene Tree", PROPERTY_HINT_TYPE_STRING,
			"SceneTree");
}

String VisualScriptSceneTree::get_caption() const {
	return RTR("Get Scene Tree");
}

class VisualScriptNodeInstanceSceneTree : public VisualScriptNodeInstance {
public:
	VisualScriptSceneTree *node = nullptr;
	VisualScriptInstance *instance = nullptr;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		Node *step_scenetree_instance_node = Object::cast_to<Node>(instance->get_owner_ptr());
		if (!step_scenetree_instance_node) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str = "Base object is not a Node!";
			return 0;
		}

		SceneTree *tree = step_scenetree_instance_node->get_tree();
		if (!tree) {
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			r_error_str =
					"Attempt to get SceneTree while node is not in the active tree.";
			return 0;
		}

		*p_outputs[0] = tree;

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptSceneTree::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceSceneTree *instance =
			memnew(VisualScriptNodeInstanceSceneTree);
	instance->node = this;
	instance->instance = p_instance;
	return instance;
}

VisualScriptSceneTree::TypeGuess
VisualScriptSceneTree::guess_output_type(TypeGuess *p_inputs,
		int p_output) const {
	TypeGuess tg;
	tg.type = Variant::OBJECT;
	tg.gdclass = SNAME("SceneTree");
	return tg;
}

void VisualScriptSceneTree::_validate_property(PropertyInfo &p_property) const {
}

void VisualScriptSceneTree::_bind_methods() {}

VisualScriptSceneTree::VisualScriptSceneTree() {}

//////////////////////////////////////////
////////////////RESPATH///////////
//////////////////////////////////////////

int VisualScriptResourcePath::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptResourcePath::has_input_sequence_port() const { return false; }

int VisualScriptResourcePath::get_input_value_port_count() const { return 0; }

int VisualScriptResourcePath::get_output_value_port_count() const { return 1; }

String
VisualScriptResourcePath::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo
VisualScriptResourcePath::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptResourcePath::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(Variant::STRING, path);
}

String VisualScriptResourcePath::get_caption() const {
	return RTR("Resource Path");
}

void VisualScriptResourcePath::set_resource_path(const String &p_path) {
	path = p_path;
	notify_property_list_changed();
	ports_changed_notify();
}

String VisualScriptResourcePath::get_resource_path() { return path; }

class VisualScriptNodeInstanceResourcePath : public VisualScriptNodeInstance {
public:
	String path;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = path;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptResourcePath::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceResourcePath *instance =
			memnew(VisualScriptNodeInstanceResourcePath);
	instance->path = path;
	return instance;
}

void VisualScriptResourcePath::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_resource_path", "path"),
			&VisualScriptResourcePath::set_resource_path);
	ClassDB::bind_method(D_METHOD("get_resource_path"),
			&VisualScriptResourcePath::get_resource_path);

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "path", PROPERTY_HINT_FILE),
			"set_resource_path", "get_resource_path");
}

VisualScriptResourcePath::VisualScriptResourcePath() { path = ""; }

//////////////////////////////////////////
////////////////SELF///////////
//////////////////////////////////////////

int VisualScriptSelf::get_output_sequence_port_count() const { return 0; }

bool VisualScriptSelf::has_input_sequence_port() const { return false; }

int VisualScriptSelf::get_input_value_port_count() const { return 0; }

int VisualScriptSelf::get_output_value_port_count() const { return 1; }

String VisualScriptSelf::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptSelf::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo VisualScriptSelf::get_output_value_port_info(int p_idx) const {
	StringName type_name;
	if (get_visual_script().is_valid()) {
		type_name = get_visual_script()->get_instance_base_type();
	} else {
		type_name = SNAME("instance");
	}

	return PropertyInfo(Variant::OBJECT, type_name);
}

String VisualScriptSelf::get_caption() const { return RTR("Get Self"); }

class VisualScriptNodeInstanceSelf : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = instance->get_owner_ptr();
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptSelf::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceSelf *instance = memnew(VisualScriptNodeInstanceSelf);
	instance->instance = p_instance;
	return instance;
}

VisualScriptSelf::TypeGuess
VisualScriptSelf::guess_output_type(TypeGuess *p_inputs, int p_output) const {
	VisualScriptSceneNode::TypeGuess tg;
	tg.type = Variant::OBJECT;
	tg.gdclass = SNAME("Object");

	Ref<Script> guess_output_script = get_visual_script();
	if (!guess_output_script.is_valid()) {
		return tg;
	}

	tg.gdclass = guess_output_script->get_instance_base_type();
	tg.script = guess_output_script;

	return tg;
}

void VisualScriptSelf::_bind_methods() {}

VisualScriptSelf::VisualScriptSelf() {}

//////////////////////////////////////////
////////////////CUSTOM (SCRIPTED)///////////
//////////////////////////////////////////

int VisualScriptCustomNode::get_output_sequence_port_count() const {
	int ret;
	if (GDVIRTUAL_CALL(_get_output_sequence_port_count, ret)) {
		return ret;
	}
	return 0;
}

bool VisualScriptCustomNode::has_input_sequence_port() const {
	bool ret;
	if (GDVIRTUAL_CALL(_has_input_sequence_port, ret)) {
		return ret;
	}
	return false;
}

int VisualScriptCustomNode::get_input_value_port_count() const {
	int ret;
	if (GDVIRTUAL_CALL(_get_input_value_port_count, ret)) {
		return ret;
	}
	return 0;
}

int VisualScriptCustomNode::get_output_value_port_count() const {
	int ret;
	if (GDVIRTUAL_CALL(_get_output_value_port_count, ret)) {
		return ret;
	}
	return 0;
}

String VisualScriptCustomNode::get_output_sequence_port_text(int p_port) const {
	String ret;
	if (GDVIRTUAL_CALL(_get_output_sequence_port_text, p_port, ret)) {
		return ret;
	}

	return String();
}

PropertyInfo
VisualScriptCustomNode::get_input_value_port_info(int p_idx) const {
	PropertyInfo info;
	{
		int type;
		if (GDVIRTUAL_CALL(_get_input_value_port_type, p_idx, type)) {
			info.type = Variant::Type(type);
		}
	}
	{
		String input_port_name;
		if (GDVIRTUAL_CALL(_get_input_value_port_name, p_idx, input_port_name)) {
			info.name = input_port_name;
		}
	}
	{
		int hint;
		if (GDVIRTUAL_CALL(_get_input_value_port_hint, p_idx, hint)) {
			info.hint = PropertyHint(hint);
		}
	}

	{
		String hint_string;
		if (GDVIRTUAL_CALL(_get_input_value_port_hint_string, p_idx, hint_string)) {
			info.hint_string = hint_string;
		}
	}

	return info;
}

PropertyInfo
VisualScriptCustomNode::get_output_value_port_info(int p_idx) const {
	PropertyInfo info;
	{
		int type;
		if (GDVIRTUAL_CALL(_get_output_value_port_type, p_idx, type)) {
			info.type = Variant::Type(type);
		}
	}
	{
		String output_port_name;
		if (GDVIRTUAL_CALL(_get_output_value_port_name, p_idx, output_port_name)) {
			info.name = output_port_name;
		}
	}
	{
		int hint;
		if (GDVIRTUAL_CALL(_get_output_value_port_hint, p_idx, hint)) {
			info.hint = PropertyHint(hint);
		}
	}

	{
		String hint_string;
		if (GDVIRTUAL_CALL(_get_output_value_port_hint_string, p_idx,
					hint_string)) {
			info.hint_string = hint_string;
		}
	}
	return info;
}

VisualScriptCustomNode::TypeGuess
VisualScriptCustomNode::guess_output_type(TypeGuess *p_inputs,
		int p_output) const {
	TypeGuess tg;
	PropertyInfo pi =
			VisualScriptCustomNode::get_output_value_port_info(p_output);
	tg.type = pi.type;
	if (pi.type == Variant::OBJECT) {
		if (pi.hint == PROPERTY_HINT_RESOURCE_TYPE) {
			if (pi.hint_string.is_resource_file()) {
				tg.script = ResourceLoader::load(pi.hint_string);
			} else if (ClassDB::class_exists(pi.hint_string)) {
				tg.gdclass = pi.hint_string;
			}
		}
	}
	return tg;
}

String VisualScriptCustomNode::get_caption() const {
	String ret;
	if (GDVIRTUAL_CALL(_get_caption, ret)) {
		return ret;
	}
	return RTR("CustomNode");
}

String VisualScriptCustomNode::get_text() const {
	String ret;
	if (GDVIRTUAL_CALL(_get_text, ret)) {
		return ret;
	}
	return "";
}

String VisualScriptCustomNode::get_category() const {
	String ret;
	if (GDVIRTUAL_CALL(_get_category, ret)) {
		return ret;
	}
	return "Custom";
}

class VisualScriptNodeInstanceCustomNode : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;
	VisualScriptCustomNode *node = nullptr;
	int in_count = 0;
	int out_count = 0;
	int work_mem_size = 0;

	virtual int get_working_memory_size() const override { return work_mem_size; }
	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		if (GDVIRTUAL_IS_OVERRIDDEN_PTR(node, _step)) {
			Array in_values;
			Array out_values;
			Array work_mem;

			in_values.resize(in_count);

			for (int i = 0; i < in_count; i++) {
				in_values[i] = *p_inputs[i];
			}

			out_values.resize(out_count);

			work_mem.resize(work_mem_size);

			for (int i = 0; i < work_mem_size; i++) {
				work_mem[i] = p_working_mem[i];
			}

			int ret_out;

			Variant ret;
			GDVIRTUAL_CALL_PTR(node, _step, in_values, out_values, p_start_mode,
					work_mem, ret);
			if (ret.get_type() == Variant::STRING) {
				r_error_str = ret;
				r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
				return 0;
			} else if (ret.is_num()) {
				ret_out = ret;
			} else {
				r_error_str = RTR("Invalid return value from _step(), must be integer "
								  "(seq out), or string (error).");
				r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
				return 0;
			}

			for (int i = 0; i < out_count; i++) {
				if (i < out_values.size()) {
					*p_outputs[i] = out_values[i];
				}
			}

			for (int i = 0; i < work_mem_size; i++) {
				if (i < work_mem.size()) {
					p_working_mem[i] = work_mem[i];
				}
			}

			return ret_out;
		} else {
			r_error_str =
					RTR("Custom node has no _step() method, can't process graph.");
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptCustomNode::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceCustomNode *instance =
			memnew(VisualScriptNodeInstanceCustomNode);
	instance->instance = p_instance;
	instance->node = this;
	instance->in_count = get_input_value_port_count();
	instance->out_count = get_output_value_port_count();

	instance->work_mem_size = 0;
	GDVIRTUAL_CALL(_get_working_memory_size, instance->work_mem_size);

	return instance;
}

void VisualScriptCustomNode::_script_changed() {
	call_deferred(SNAME("ports_changed_notify"));
}

void VisualScriptCustomNode::_bind_methods() {
	GDVIRTUAL_BIND(_get_output_sequence_port_count);
	GDVIRTUAL_BIND(_has_input_sequence_port);
	GDVIRTUAL_BIND(_get_output_sequence_port_text, "seq_idx");

	GDVIRTUAL_BIND(_get_input_value_port_count);
	GDVIRTUAL_BIND(_get_input_value_port_type, "input_idx");
	GDVIRTUAL_BIND(_get_input_value_port_name, "input_idx");
	GDVIRTUAL_BIND(_get_input_value_port_hint, "input_idx");
	GDVIRTUAL_BIND(_get_input_value_port_hint_string, "input_idx");

	GDVIRTUAL_BIND(_get_output_value_port_count);
	GDVIRTUAL_BIND(_get_output_value_port_type, "output_idx");
	GDVIRTUAL_BIND(_get_output_value_port_name, "output_idx");
	GDVIRTUAL_BIND(_get_output_value_port_hint, "output_idx");
	GDVIRTUAL_BIND(_get_output_value_port_hint_string, "output_idx");

	GDVIRTUAL_BIND(_get_caption);
	GDVIRTUAL_BIND(_get_text);
	GDVIRTUAL_BIND(_get_category);

	GDVIRTUAL_BIND(_get_working_memory_size);

	GDVIRTUAL_BIND(_step, "inputs", "outputs", "start_mode", "working_mem");

	BIND_ENUM_CONSTANT(START_MODE_BEGIN_SEQUENCE);
	BIND_ENUM_CONSTANT(START_MODE_CONTINUE_SEQUENCE);
	BIND_ENUM_CONSTANT(START_MODE_RESUME_YIELD);

	BIND_CONSTANT(STEP_PUSH_STACK_BIT);
	BIND_CONSTANT(STEP_GO_BACK_BIT);
	BIND_CONSTANT(STEP_NO_ADVANCE_BIT);
	BIND_CONSTANT(STEP_EXIT_FUNCTION_BIT);
	BIND_CONSTANT(STEP_YIELD_BIT);
}

VisualScriptCustomNode::VisualScriptCustomNode() {
	connect("script_changed",
			callable_mp(this, &VisualScriptCustomNode::_script_changed));
}

//////////////////////////////////////////
////////////////SUBCALL///////////
//////////////////////////////////////////

int VisualScriptSubCall::get_output_sequence_port_count() const { return 1; }

bool VisualScriptSubCall::has_input_sequence_port() const { return true; }

int VisualScriptSubCall::get_input_value_port_count() const {
	Ref<Script> input_value_script = get_script();

	if (input_value_script.is_valid() &&
			input_value_script->has_method(VisualScriptLanguage::singleton->_subcall)) {
		MethodInfo mi =
				input_value_script->get_method_info(VisualScriptLanguage::singleton->_subcall);
		return mi.arguments.size();
	}

	return 0;
}

int VisualScriptSubCall::get_output_value_port_count() const { return 1; }

String VisualScriptSubCall::get_output_sequence_port_text(int p_port) const {
	return String();
}

PropertyInfo VisualScriptSubCall::get_input_value_port_info(int p_idx) const {
	Ref<Script> input_value_port_script = get_script();
	if (input_value_port_script.is_valid() &&
			input_value_port_script->has_method(VisualScriptLanguage::singleton->_subcall)) {
		MethodInfo mi =
				input_value_port_script->get_method_info(VisualScriptLanguage::singleton->_subcall);
		return mi.arguments[p_idx];
	}

	return PropertyInfo();
}

PropertyInfo VisualScriptSubCall::get_output_value_port_info(int p_idx) const {
	Ref<Script> output_value_port_script = get_script();
	if (output_value_port_script.is_valid() &&
			output_value_port_script->has_method(VisualScriptLanguage::singleton->_subcall)) {
		MethodInfo mi =
				output_value_port_script->get_method_info(VisualScriptLanguage::singleton->_subcall);
		return mi.return_val;
	}
	return PropertyInfo();
}

String VisualScriptSubCall::get_caption() const { return RTR("SubCall"); }

String VisualScriptSubCall::get_text() const {
	Ref<Script> sub_call_script = get_script();
	if (sub_call_script.is_valid()) {
		if (!sub_call_script->get_name().is_empty()) {
			return sub_call_script->get_name();
		}
		if (sub_call_script->get_path().is_resource_file()) {
			return sub_call_script->get_path().get_file();
		}
		return sub_call_script->get_class();
	}
	return "";
}

String VisualScriptSubCall::get_category() const { return "custom"; }

class VisualScriptNodeInstanceSubCall : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;
	VisualScriptSubCall *subcall = nullptr;
	int input_args = 0;
	bool valid = false;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		if (!valid) {
			r_error_str =
					"Node requires a script with a _subcall(<args>) method to work.";
			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
			return 0;
		}
		*p_outputs[0] = subcall->callp(VisualScriptLanguage::singleton->_subcall,
				p_inputs, input_args, r_error);
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptSubCall::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceSubCall *instance =
			memnew(VisualScriptNodeInstanceSubCall);
	instance->instance = p_instance;
	Ref<Script> instance_sub_call_script = get_script();
	if (instance_sub_call_script.is_valid() &&
			instance_sub_call_script->has_method(VisualScriptLanguage::singleton->_subcall)) {
		instance->valid = true;
		instance->input_args = get_input_value_port_count();
	} else {
		instance->valid = false;
	}
	return instance;
}

void VisualScriptSubCall::_bind_methods() {
	// Since this is script only, registering virtual function is no longer valid.
	// Will have to go in docs.
}

VisualScriptSubCall::VisualScriptSubCall() {}

//////////////////////////////////////////
////////////////Constructor///////////
//////////////////////////////////////////

int VisualScriptConstructor::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptConstructor::has_input_sequence_port() const { return false; }

int VisualScriptConstructor::get_input_value_port_count() const {
	return constructor.arguments.size();
}

int VisualScriptConstructor::get_output_value_port_count() const { return 1; }

String
VisualScriptConstructor::get_output_sequence_port_text(int p_port) const {
	return "";
}

PropertyInfo
VisualScriptConstructor::get_input_value_port_info(int p_idx) const {
	return constructor.arguments[p_idx];
}

PropertyInfo
VisualScriptConstructor::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(type, "value");
}

String VisualScriptConstructor::get_caption() const {
	return vformat(RTR("Construct %s"), Variant::get_type_name(type));
}

String VisualScriptConstructor::get_category() const { return "functions"; }

void VisualScriptConstructor::set_constructor_type(Variant::Type p_type) {
	if (type == p_type) {
		return;
	}

	type = p_type;
	ports_changed_notify();
}

Variant::Type VisualScriptConstructor::get_constructor_type() const {
	return type;
}

void VisualScriptConstructor::set_constructor(const Dictionary &p_info) {
	constructor = MethodInfo::from_dict(p_info);
	ports_changed_notify();
}

Dictionary VisualScriptConstructor::get_constructor() const {
	return constructor;
}

class VisualScriptNodeInstanceConstructor : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;
	Variant::Type type;
	int argcount = 0;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		Callable::CallError ce;
		Variant::construct(type, *p_outputs[0], p_inputs, argcount, ce);
		if (ce.error != Callable::CallError::CALL_OK) {
			r_error_str = "Invalid arguments for constructor";
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptConstructor::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceConstructor *instance =
			memnew(VisualScriptNodeInstanceConstructor);
	instance->instance = p_instance;
	instance->type = type;
	instance->argcount = constructor.arguments.size();
	return instance;
}

void VisualScriptConstructor::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_constructor_type", "type"),
			&VisualScriptConstructor::set_constructor_type);
	ClassDB::bind_method(D_METHOD("get_constructor_type"),
			&VisualScriptConstructor::get_constructor_type);

	ClassDB::bind_method(D_METHOD("set_constructor", "constructor"),
			&VisualScriptConstructor::set_constructor);
	ClassDB::bind_method(D_METHOD("get_constructor"),
			&VisualScriptConstructor::get_constructor);

	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_NONE, "",
						 PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL),
			"set_constructor_type", "get_constructor_type");
	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "constructor",
						 PROPERTY_HINT_NONE, "",
						 PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL),
			"set_constructor", "get_constructor");
}

VisualScriptConstructor::VisualScriptConstructor() { type = Variant::NIL; }

static HashMap<String, Pair<Variant::Type, MethodInfo>> constructor_map;

static Ref<VisualScriptNode> create_constructor_node(const String &p_name) {
	ERR_FAIL_COND_V(!constructor_map.has(p_name), Ref<VisualScriptNode>());

	Ref<VisualScriptConstructor> vsc;
	vsc.instantiate();
	vsc->set_constructor_type(constructor_map[p_name].first);
	vsc->set_constructor(constructor_map[p_name].second);

	return vsc;
}

//////////////////////////////////////////
////////////////LocalVar///////////
//////////////////////////////////////////

int VisualScriptLocalVar::get_output_sequence_port_count() const { return 0; }

bool VisualScriptLocalVar::has_input_sequence_port() const { return false; }

int VisualScriptLocalVar::get_input_value_port_count() const { return 0; }

int VisualScriptLocalVar::get_output_value_port_count() const { return 1; }

String VisualScriptLocalVar::get_output_sequence_port_text(int p_port) const {
	return "";
}

PropertyInfo VisualScriptLocalVar::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo VisualScriptLocalVar::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(type, name);
}

String VisualScriptLocalVar::get_caption() const {
	return RTR("Get Local Var");
}

String VisualScriptLocalVar::get_category() const { return "data"; }

void VisualScriptLocalVar::set_var_name(const StringName &p_name) {
	if (name == p_name) {
		return;
	}

	name = p_name;
	ports_changed_notify();
}

StringName VisualScriptLocalVar::get_var_name() const { return name; }

void VisualScriptLocalVar::set_var_type(Variant::Type p_type) {
	type = p_type;
	ports_changed_notify();
}

Variant::Type VisualScriptLocalVar::get_var_type() const { return type; }

class VisualScriptNodeInstanceLocalVar : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;
	StringName name;

	virtual int get_working_memory_size() const override { return 1; }
	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_outputs[0] = *p_working_mem;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptLocalVar::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceLocalVar *instance =
			memnew(VisualScriptNodeInstanceLocalVar);
	instance->instance = p_instance;
	instance->name = name;

	return instance;
}

void VisualScriptLocalVar::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_var_name", "name"),
			&VisualScriptLocalVar::set_var_name);
	ClassDB::bind_method(D_METHOD("get_var_name"),
			&VisualScriptLocalVar::get_var_name);

	ClassDB::bind_method(D_METHOD("set_var_type", "type"),
			&VisualScriptLocalVar::set_var_type);
	ClassDB::bind_method(D_METHOD("get_var_type"),
			&VisualScriptLocalVar::get_var_type);

	String argt = "Any";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "var_name"), "set_var_name",
			"get_var_name");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt),
			"set_var_type", "get_var_type");
}

VisualScriptLocalVar::VisualScriptLocalVar() {
	name = "new_local";
	type = Variant::NIL;
}

//////////////////////////////////////////
////////////////LocalVar///////////
//////////////////////////////////////////

int VisualScriptLocalVarSet::get_output_sequence_port_count() const {
	return 1;
}

bool VisualScriptLocalVarSet::has_input_sequence_port() const { return true; }

int VisualScriptLocalVarSet::get_input_value_port_count() const { return 1; }

int VisualScriptLocalVarSet::get_output_value_port_count() const { return 1; }

String
VisualScriptLocalVarSet::get_output_sequence_port_text(int p_port) const {
	return "";
}

PropertyInfo
VisualScriptLocalVarSet::get_input_value_port_info(int p_idx) const {
	return PropertyInfo(type, "set");
}

PropertyInfo
VisualScriptLocalVarSet::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(type, "get");
}

String VisualScriptLocalVarSet::get_caption() const {
	return RTR("Set Local Var");
}

String VisualScriptLocalVarSet::get_text() const { return name; }

String VisualScriptLocalVarSet::get_category() const { return "data"; }

void VisualScriptLocalVarSet::set_var_name(const StringName &p_name) {
	if (name == p_name) {
		return;
	}

	name = p_name;
	ports_changed_notify();
}

StringName VisualScriptLocalVarSet::get_var_name() const { return name; }

void VisualScriptLocalVarSet::set_var_type(Variant::Type p_type) {
	type = p_type;
	ports_changed_notify();
}

Variant::Type VisualScriptLocalVarSet::get_var_type() const { return type; }

class VisualScriptNodeInstanceLocalVarSet : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;
	StringName name;

	virtual int get_working_memory_size() const override { return 1; }
	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		*p_working_mem = *p_inputs[0];
		*p_outputs[0] = *p_working_mem;
		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptLocalVarSet::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceLocalVarSet *instance =
			memnew(VisualScriptNodeInstanceLocalVarSet);
	instance->instance = p_instance;
	instance->name = name;

	return instance;
}

void VisualScriptLocalVarSet::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_var_name", "name"),
			&VisualScriptLocalVarSet::set_var_name);
	ClassDB::bind_method(D_METHOD("get_var_name"),
			&VisualScriptLocalVarSet::get_var_name);

	ClassDB::bind_method(D_METHOD("set_var_type", "type"),
			&VisualScriptLocalVarSet::set_var_type);
	ClassDB::bind_method(D_METHOD("get_var_type"),
			&VisualScriptLocalVarSet::get_var_type);

	String argt = "Any";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "var_name"), "set_var_name",
			"get_var_name");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt),
			"set_var_type", "get_var_type");
}

VisualScriptLocalVarSet::VisualScriptLocalVarSet() {
	name = "new_local";
	type = Variant::NIL;
}

//////////////////////////////////////////
////////////////LocalVar///////////
//////////////////////////////////////////

int VisualScriptInputAction::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptInputAction::has_input_sequence_port() const { return false; }

int VisualScriptInputAction::get_input_value_port_count() const { return 0; }

int VisualScriptInputAction::get_output_value_port_count() const { return 1; }

String
VisualScriptInputAction::get_output_sequence_port_text(int p_port) const {
	return "";
}

PropertyInfo
VisualScriptInputAction::get_input_value_port_info(int p_idx) const {
	return PropertyInfo();
}

PropertyInfo
VisualScriptInputAction::get_output_value_port_info(int p_idx) const {
	String mstr;
	switch (mode) {
		case MODE_PRESSED: {
			mstr = "pressed";
		} break;
		case MODE_RELEASED: {
			mstr = "not pressed";
		} break;
		case MODE_JUST_PRESSED: {
			mstr = "just pressed";
		} break;
		case MODE_JUST_RELEASED: {
			mstr = "just released";
		} break;
	}

	return PropertyInfo(Variant::BOOL, mstr);
}

String VisualScriptInputAction::get_caption() const {
	return vformat(RTR("Action %s"), name);
}

String VisualScriptInputAction::get_category() const { return "data"; }

void VisualScriptInputAction::set_action_name(const StringName &p_name) {
	if (name == p_name) {
		return;
	}

	name = p_name;
	ports_changed_notify();
}

StringName VisualScriptInputAction::get_action_name() const { return name; }

void VisualScriptInputAction::set_action_mode(Mode p_mode) {
	if (mode == p_mode) {
		return;
	}

	mode = p_mode;
	ports_changed_notify();
}

VisualScriptInputAction::Mode VisualScriptInputAction::get_action_mode() const {
	return mode;
}

class VisualScriptNodeInstanceInputAction : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;
	StringName action;
	VisualScriptInputAction::Mode mode;

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		switch (mode) {
			case VisualScriptInputAction::MODE_PRESSED: {
				*p_outputs[0] = Input::get_singleton()->is_action_pressed(action);
			} break;
			case VisualScriptInputAction::MODE_RELEASED: {
				*p_outputs[0] = !Input::get_singleton()->is_action_pressed(action);
			} break;
			case VisualScriptInputAction::MODE_JUST_PRESSED: {
				*p_outputs[0] = Input::get_singleton()->is_action_just_pressed(action);
			} break;
			case VisualScriptInputAction::MODE_JUST_RELEASED: {
				*p_outputs[0] = Input::get_singleton()->is_action_just_released(action);
			} break;
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptInputAction::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceInputAction *instance =
			memnew(VisualScriptNodeInstanceInputAction);
	instance->instance = p_instance;
	instance->action = name;
	instance->mode = mode;

	return instance;
}

void VisualScriptInputAction::_validate_property(
		PropertyInfo &p_property) const {
	if (p_property.name == "action") {
		p_property.hint = PROPERTY_HINT_ENUM;
		String actions;

		List<PropertyInfo> pinfo;
		ProjectSettings::get_singleton()->get_property_list(&pinfo);
		Vector<String> al;

		for (const PropertyInfo &pi : pinfo) {
			if (!pi.name.begins_with("input/")) {
				continue;
			}

			String validate_input_name = pi.name.substr(pi.name.find("/") + 1, pi.name.length());

			al.push_back(validate_input_name);
		}

		al.sort();

		for (int i = 0; i < al.size(); i++) {
			if (!actions.is_empty()) {
				actions += ",";
			}
			actions += al[i];
		}

		p_property.hint_string = actions;
	}
}

void VisualScriptInputAction::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_action_name", "name"),
			&VisualScriptInputAction::set_action_name);
	ClassDB::bind_method(D_METHOD("get_action_name"),
			&VisualScriptInputAction::get_action_name);

	ClassDB::bind_method(D_METHOD("set_action_mode", "mode"),
			&VisualScriptInputAction::set_action_mode);
	ClassDB::bind_method(D_METHOD("get_action_mode"),
			&VisualScriptInputAction::get_action_mode);

	ADD_PROPERTY(PropertyInfo(Variant::STRING, "action"), "set_action_name",
			"get_action_name");
	ADD_PROPERTY(PropertyInfo(Variant::INT, "mode", PROPERTY_HINT_ENUM,
						 "Pressed,Released,JustPressed,JustReleased"),
			"set_action_mode", "get_action_mode");

	BIND_ENUM_CONSTANT(MODE_PRESSED);
	BIND_ENUM_CONSTANT(MODE_RELEASED);
	BIND_ENUM_CONSTANT(MODE_JUST_PRESSED);
	BIND_ENUM_CONSTANT(MODE_JUST_RELEASED);
}

VisualScriptInputAction::VisualScriptInputAction() {
	name = "";
	mode = MODE_PRESSED;
}

//////////////////////////////////////////
////////////////Constructor///////////
//////////////////////////////////////////

int VisualScriptDeconstruct::get_output_sequence_port_count() const {
	return 0;
}

bool VisualScriptDeconstruct::has_input_sequence_port() const { return false; }

int VisualScriptDeconstruct::get_input_value_port_count() const { return 1; }

int VisualScriptDeconstruct::get_output_value_port_count() const {
	return elements.size();
}

String
VisualScriptDeconstruct::get_output_sequence_port_text(int p_port) const {
	return "";
}

PropertyInfo
VisualScriptDeconstruct::get_input_value_port_info(int p_idx) const {
	return PropertyInfo(type, "value");
}

PropertyInfo
VisualScriptDeconstruct::get_output_value_port_info(int p_idx) const {
	return PropertyInfo(elements[p_idx].type, elements[p_idx].name);
}

String VisualScriptDeconstruct::get_caption() const {
	return vformat(RTR("Deconstruct %s"), Variant::get_type_name(type));
}

String VisualScriptDeconstruct::get_category() const { return "functions"; }

void VisualScriptDeconstruct::_update_elements() {
	elements.clear();
	Variant v;
	Callable::CallError ce;
	Variant::construct(type, v, nullptr, 0, ce);

	List<PropertyInfo> pinfo;
	v.get_property_list(&pinfo);

	for (const PropertyInfo &E : pinfo) {
		Element e;
		e.name = E.name;
		e.type = E.type;
		elements.push_back(e);
	}
}

void VisualScriptDeconstruct::set_deconstruct_type(Variant::Type p_type) {
	if (type == p_type) {
		return;
	}

	type = p_type;
	_update_elements();
	ports_changed_notify();
	notify_property_list_changed(); // to make input appear/disappear
}

Variant::Type VisualScriptDeconstruct::get_deconstruct_type() const {
	return type;
}

void VisualScriptDeconstruct::_set_elem_cache(const Array &p_elements) {
	ERR_FAIL_COND(p_elements.size() % 2 == 1);
	elements.resize(p_elements.size() / 2);
	for (int i = 0; i < elements.size(); i++) {
		elements.write[i].name = p_elements[i * 2 + 0];
		elements.write[i].type = Variant::Type(int(p_elements[i * 2 + 1]));
	}
}

Array VisualScriptDeconstruct::_get_elem_cache() const {
	Array ret;
	for (int i = 0; i < elements.size(); i++) {
		ret.push_back(elements[i].name);
		ret.push_back(elements[i].type);
	}
	return ret;
}

class VisualScriptNodeInstanceDeconstruct : public VisualScriptNodeInstance {
public:
	VisualScriptInstance *instance = nullptr;
	Vector<StringName> outputs;

	// virtual int get_working_memory_size() const override { return 0; }

	virtual int step(const Variant **p_inputs, Variant **p_outputs,
			StartMode p_start_mode, Variant *p_working_mem,
			Callable::CallError &r_error, String &r_error_str) override {
		Variant in = *p_inputs[0];

		for (int i = 0; i < outputs.size(); i++) {
			bool valid;
			*p_outputs[i] = in.get(outputs[i], &valid);
			if (!valid) {
				r_error_str = "Can't obtain element '" + String(outputs[i]) +
						"' from " + Variant::get_type_name(in.get_type());
				r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
				return 0;
			}
		}

		return 0;
	}
};

VisualScriptNodeInstance *
VisualScriptDeconstruct::instantiate(VisualScriptInstance *p_instance) {
	VisualScriptNodeInstanceDeconstruct *instance =
			memnew(VisualScriptNodeInstanceDeconstruct);
	instance->instance = p_instance;
	instance->outputs.resize(elements.size());
	for (int i = 0; i < elements.size(); i++) {
		instance->outputs.write[i] = elements[i].name;
	}

	return instance;
}

void VisualScriptDeconstruct::_validate_property(
		PropertyInfo &p_property) const {}

void VisualScriptDeconstruct::_bind_methods() {
	ClassDB::bind_method(D_METHOD("set_deconstruct_type", "type"),
			&VisualScriptDeconstruct::set_deconstruct_type);
	ClassDB::bind_method(D_METHOD("get_deconstruct_type"),
			&VisualScriptDeconstruct::get_deconstruct_type);

	ClassDB::bind_method(D_METHOD("_set_elem_cache", "_cache"),
			&VisualScriptDeconstruct::_set_elem_cache);
	ClassDB::bind_method(D_METHOD("_get_elem_cache"),
			&VisualScriptDeconstruct::_get_elem_cache);

	String argt = "Any";
	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		argt += "," + Variant::get_type_name(Variant::Type(i));
	}

	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt),
			"set_deconstruct_type", "get_deconstruct_type");
	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "elem_cache", PROPERTY_HINT_NONE,
						 "",
						 PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL),
			"_set_elem_cache", "_get_elem_cache");
}

VisualScriptDeconstruct::VisualScriptDeconstruct() { type = Variant::NIL; }

template <Variant::Type T>
static Ref<VisualScriptNode> create_node_deconst_typed(const String &p_name) {
	Ref<VisualScriptDeconstruct> node;
	node.instantiate();
	node->set_deconstruct_type(T);
	return node;
}

void register_visual_script_nodes() {
	VisualScriptLanguage::singleton->add_register_func(
			"data/set_variable", create_node_generic<VisualScriptVariableSet>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/get_variable", create_node_generic<VisualScriptVariableGet>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/engine_singleton",
			create_node_generic<VisualScriptEngineSingleton>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/scene_node", create_node_generic<VisualScriptSceneNode>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/scene_tree", create_node_generic<VisualScriptSceneTree>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/resource_path", create_node_generic<VisualScriptResourcePath>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/self", create_node_generic<VisualScriptSelf>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/get_local_variable", create_node_generic<VisualScriptLocalVar>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/set_local_variable", create_node_generic<VisualScriptLocalVarSet>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/preload", create_node_generic<VisualScriptPreload>);
	VisualScriptLanguage::singleton->add_register_func(
			"data/action", create_node_generic<VisualScriptInputAction>);

	VisualScriptLanguage::singleton->add_register_func(
			"constants/constant", create_node_generic<VisualScriptConstant>);
	VisualScriptLanguage::singleton->add_register_func(
			"constants/math_constant", create_node_generic<VisualScriptMathConstant>);
	VisualScriptLanguage::singleton->add_register_func(
			"constants/class_constant",
			create_node_generic<VisualScriptClassConstant>);
	VisualScriptLanguage::singleton->add_register_func(
			"constants/global_constant",
			create_node_generic<VisualScriptGlobalConstant>);
	VisualScriptLanguage::singleton->add_register_func(
			"constants/basic_type_constant",
			create_node_generic<VisualScriptBasicTypeConstant>);

	VisualScriptLanguage::singleton->add_register_func(
			"custom/custom_node", create_node_generic<VisualScriptCustomNode>);
	VisualScriptLanguage::singleton->add_register_func(
			"custom/sub_call", create_node_generic<VisualScriptSubCall>);

	VisualScriptLanguage::singleton->add_register_func(
			"index/get_index", create_node_generic<VisualScriptIndexGet>);
	VisualScriptLanguage::singleton->add_register_func(
			"index/set_index", create_node_generic<VisualScriptIndexSet>);

	VisualScriptLanguage::singleton->add_register_func(
			"operators/compare/equal", create_op_node<Variant::OP_EQUAL>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/compare/not_equal", create_op_node<Variant::OP_NOT_EQUAL>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/compare/less", create_op_node<Variant::OP_LESS>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/compare/less_equal", create_op_node<Variant::OP_LESS_EQUAL>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/compare/greater", create_op_node<Variant::OP_GREATER>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/compare/greater_equal",
			create_op_node<Variant::OP_GREATER_EQUAL>);
	// mathematic
	VisualScriptLanguage::singleton->add_register_func(
			"operators/math/add", create_op_node<Variant::OP_ADD>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/math/subtract", create_op_node<Variant::OP_SUBTRACT>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/math/multiply", create_op_node<Variant::OP_MULTIPLY>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/math/divide", create_op_node<Variant::OP_DIVIDE>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/math/negate", create_op_node<Variant::OP_NEGATE>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/math/positive", create_op_node<Variant::OP_POSITIVE>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/math/remainder", create_op_node<Variant::OP_MODULE>);
	// bitwise
	VisualScriptLanguage::singleton->add_register_func(
			"operators/bitwise/shift_left", create_op_node<Variant::OP_SHIFT_LEFT>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/bitwise/shift_right", create_op_node<Variant::OP_SHIFT_RIGHT>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/bitwise/bit_and", create_op_node<Variant::OP_BIT_AND>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/bitwise/bit_or", create_op_node<Variant::OP_BIT_OR>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/bitwise/bit_xor", create_op_node<Variant::OP_BIT_XOR>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/bitwise/bit_negate", create_op_node<Variant::OP_BIT_NEGATE>);
	// logic
	VisualScriptLanguage::singleton->add_register_func(
			"operators/logic/and", create_op_node<Variant::OP_AND>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/logic/or", create_op_node<Variant::OP_OR>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/logic/xor", create_op_node<Variant::OP_XOR>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/logic/not", create_op_node<Variant::OP_NOT>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/logic/in", create_op_node<Variant::OP_IN>);
	VisualScriptLanguage::singleton->add_register_func(
			"operators/logic/select", create_node_generic<VisualScriptSelect>);

	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::VECTOR2),
			create_node_deconst_typed<Variant::Type::VECTOR2>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" +
					Variant::get_type_name(Variant::Type::VECTOR2I),
			create_node_deconst_typed<Variant::Type::VECTOR2I>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::VECTOR3),
			create_node_deconst_typed<Variant::Type::VECTOR3>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" +
					Variant::get_type_name(Variant::Type::VECTOR3I),
			create_node_deconst_typed<Variant::Type::VECTOR3I>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::VECTOR4),
			create_node_deconst_typed<Variant::Type::VECTOR4>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" +
					Variant::get_type_name(Variant::Type::VECTOR4I),
			create_node_deconst_typed<Variant::Type::VECTOR4I>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::COLOR),
			create_node_deconst_typed<Variant::Type::COLOR>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::RECT2),
			create_node_deconst_typed<Variant::Type::RECT2>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::RECT2I),
			create_node_deconst_typed<Variant::Type::RECT2I>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" +
					Variant::get_type_name(Variant::Type::TRANSFORM2D),
			create_node_deconst_typed<Variant::Type::TRANSFORM2D>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::PLANE),
			create_node_deconst_typed<Variant::Type::PLANE>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" +
					Variant::get_type_name(Variant::Type::QUATERNION),
			create_node_deconst_typed<Variant::Type::QUATERNION>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::AABB),
			create_node_deconst_typed<Variant::Type::AABB>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" + Variant::get_type_name(Variant::Type::BASIS),
			create_node_deconst_typed<Variant::Type::BASIS>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" +
					Variant::get_type_name(Variant::Type::TRANSFORM3D),
			create_node_deconst_typed<Variant::Type::TRANSFORM3D>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/deconstruct/" +
					Variant::get_type_name(Variant::Type::PROJECTION),
			create_node_deconst_typed<Variant::Type::PROJECTION>);
	VisualScriptLanguage::singleton->add_register_func(
			"functions/compose_array", create_node_generic<VisualScriptComposeArray>);

	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
		List<MethodInfo> constructors;
		Variant::get_constructor_list(Variant::Type(i), &constructors);

		for (const MethodInfo &E : constructors) {
			if (E.arguments.size() > 0) {
				String constructor_name = "functions/constructors/" +
						Variant::get_type_name(Variant::Type(i)) + "(";
				for (int j = 0; j < E.arguments.size(); j++) {
					if (j > 0) {
						constructor_name += ", ";
					}
					if (E.arguments.size() == 1) {
						constructor_name += Variant::get_type_name(E.arguments[j].type);
					} else {
						constructor_name += E.arguments[j].name;
					}
				}
				constructor_name += ")";
				VisualScriptLanguage::singleton->add_register_func(
						constructor_name, create_constructor_node);
				Pair<Variant::Type, MethodInfo> pair;
				pair.first = Variant::Type(i);
				pair.second = E;
				constructor_map[constructor_name] = pair;
			}
		}
	}
}

void unregister_visual_script_nodes() { constructor_map.clear(); }