//////////////////////////////////////////

int VisualScriptYield::get_output_sequence_port_count() const {

return 1;

}

bool VisualScriptYield::has_input_sequence_port() const {

return true;

}

int VisualScriptYield::get_input_value_port_count() const {

return 0;

}

return 0;

}

String VisualScriptYield::get_output_sequence_port_text(int p_port) const {

return String();

}

PropertyInfo VisualScriptYield::get_input_value_port_info(int p_idx) const {

return PropertyInfo();

}

PropertyInfo VisualScriptYield::get_output_value_port_info(int p_idx) const {

return PropertyInfo();

}

String VisualScriptYield::get_caption() const {

return yield_mode == YIELD_RETURN ? "Yield" : "Wait";

}

String VisualScriptYield::get_text() const {

switch (yield_mode) {

case YIELD_RETURN:

return "";

//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return 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) {

if (p_start_mode == START_MODE_RESUME_YIELD) {

return 0; //resuming yield

} else {

int ret = STEP_YIELD_BIT;

switch (mode) {

case VisualScriptYield::YIELD_RETURN:

ret = STEP_EXIT_FUNCTION_BIT;

break; //return the yield

};

VisualScriptNodeInstance *VisualScriptYield::instance(VisualScriptInstance *p_instance) {

VisualScriptNodeInstanceYield *instance = memnew(VisualScriptNodeInstanceYield);

//instance->instance=p_instance;

instance->mode = yield_mode;

}

void VisualScriptYield::set_yield_mode(YieldMode p_mode) {

return;

yield_mode = p_mode;

ports_changed_notify();

_change_notify();

}

VisualScriptYield::YieldMode VisualScriptYield::get_yield_mode() {

return yield_mode;

}

void VisualScriptYield::set_wait_time(float p_time) {

return;

wait_time = p_time;

ports_changed_notify();

}

float VisualScriptYield::get_wait_time() {

return wait_time;

}

void VisualScriptYield::_validate_property(PropertyInfo &property) const {

if (property.name == "wait_time") {

if (yield_mode != YIELD_WAIT) {

property.usage = 0;

}

void VisualScriptYield::_bind_methods() {

ClassDB::bind_method(D_METHOD("set_yield_mode", "mode"), &VisualScriptYield::set_yield_mode);

ClassDB::bind_method(D_METHOD("get_yield_mode"), &VisualScriptYield::get_yield_mode);

}

VisualScriptYield::VisualScriptYield() {

yield_mode = YIELD_FRAME;

wait_time = 1;

}

template <VisualScriptYield::YieldMode MODE>

static Ref<VisualScriptNode> create_yield_node(const String &p_name) {

Ref<VisualScriptYield> node;

node.instance();

node->set_yield_mode(MODE);

//////////////////////////////////////////////////

int VisualScriptYieldSignal::get_output_sequence_port_count() const {

return 1;

}

bool VisualScriptYieldSignal::has_input_sequence_port() const {

return true;

}

#ifdef TOOLS_ENABLED

static Node *_find_script_node(Node *p_edited_scene, Node *p_current_node, const Ref<Script> &script) {

return nullptr;

Ref<Script> scr = p_current_node->get_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);

return n;

}

return nullptr;

#endif

Node *VisualScriptYieldSignal::_get_base_node() const {

#ifdef TOOLS_ENABLED

Ref<Script> script = get_visual_script();

return nullptr;

MainLoop *main_loop = OS::get_singleton()->get_main_loop();

SceneTree *scene_tree = Object::cast_to<SceneTree>(main_loop);

return nullptr;

Node *edited_scene = scene_tree->get_edited_scene_root();

return nullptr;

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

return nullptr;

return nullptr;

Node *path_to = script_node->get_node(base_path);

}

StringName VisualScriptYieldSignal::_get_base_type() const {

return get_visual_script()->get_instance_base_type();

Node *path = _get_base_node();

return path->get_class();

}

return base_type;

}

int VisualScriptYieldSignal::get_input_value_port_count() const {

return 1;

return 0;

}

MethodInfo sr;

return 0;

return sr.arguments.size();

}

String VisualScriptYieldSignal::get_output_sequence_port_text(int p_port) const {

return String();

}

PropertyInfo VisualScriptYieldSignal::get_input_value_port_info(int p_idx) const {

return PropertyInfo(Variant::OBJECT, "instance");

return PropertyInfo();

}

PropertyInfo VisualScriptYieldSignal::get_output_value_port_info(int p_idx) const {

MethodInfo sr;

return PropertyInfo(); //no signal

ERR_FAIL_INDEX_V(p_idx, sr.arguments.size(), PropertyInfo());

return sr.arguments[p_idx];

}

String VisualScriptYieldSignal::get_caption() const {

static const char *cname[3] = {

"WaitSignal",

"WaitNodeSignal",

}

String VisualScriptYieldSignal::get_text() const {

return " " + String(signal) + "()";

return " " + _get_base_type() + "." + String(signal) + "()";

}

void VisualScriptYieldSignal::set_base_type(const StringName &p_type) {

return;

base_type = p_type;

}

StringName VisualScriptYieldSignal::get_base_type() const {

return base_type;

}

void VisualScriptYieldSignal::set_signal(const StringName &p_type) {

return;

signal = p_type;

_change_notify();

ports_changed_notify();

}

return signal;

}

void VisualScriptYieldSignal::set_base_path(const NodePath &p_type) {

return;

base_path = p_type;

}

NodePath VisualScriptYieldSignal::get_base_path() const {

return base_path;

}

void VisualScriptYieldSignal::set_call_mode(CallMode p_mode) {

return;

call_mode = p_mode;

}

VisualScriptYieldSignal::CallMode VisualScriptYieldSignal::get_call_mode() const {

return call_mode;

}

void VisualScriptYieldSignal::_validate_property(PropertyInfo &property) const {

if (property.name == "base_type") {

if (call_mode != CALL_MODE_INSTANCE) {

property.usage = PROPERTY_USAGE_NOEDITOR;

if (call_mode != CALL_MODE_NODE_PATH) {

property.usage = 0;

} else {

Node *bnode = _get_base_node();

if (bnode) {

property.hint_string = bnode->get_path(); //convert to loong string

List<String> mstring;

for (List<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {

continue;

mstring.push_back(E->get().name.get_slice(":", 0));

}

String ml;

for (List<String>::Element *E = mstring.front(); E; E = E->next()) {

ml += ",";

ml += E->get();

}

}

void VisualScriptYieldSignal::_bind_methods() {

ClassDB::bind_method(D_METHOD("set_base_type", "base_type"), &VisualScriptYieldSignal::set_base_type);

ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptYieldSignal::get_base_type);

String bt;

for (int i = 0; i < Variant::VARIANT_MAX; i++) {

bt += ",";

bt += Variant::get_type_name(Variant::Type(i));

}

//virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }

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) {

if (p_start_mode == START_MODE_RESUME_YIELD) {

return 0; //resuming yield

} else {

Object *object = nullptr;

switch (call_mode) {

case VisualScriptYieldSignal::CALL_MODE_SELF: {

object = instance->get_owner_ptr();

} break;

case VisualScriptYieldSignal::CALL_MODE_NODE_PATH: {

Node *node = Object::cast_to<Node>(instance->get_owner_ptr());

if (!node) {

r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;

} break;

case VisualScriptYieldSignal::CALL_MODE_INSTANCE: {

object = *p_inputs[0];

if (!object) {

r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;

};

VisualScriptNodeInstance *VisualScriptYieldSignal::instance(VisualScriptInstance *p_instance) {

VisualScriptNodeInstanceYieldSignal *instance = memnew(VisualScriptNodeInstanceYieldSignal);

instance->node = this;

instance->instance = p_instance;

instance->output_args = get_output_value_port_count();

return instance;

}

call_mode = CALL_MODE_SELF;

base_type = "Object";

}

template <VisualScriptYieldSignal::CallMode cmode>

static Ref<VisualScriptNode> create_yield_signal_node(const String &p_name) {

Ref<VisualScriptYieldSignal> node;

node.instance();

node->set_call_mode(cmode);

}

void register_visual_script_yield_nodes() {

VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_frame", create_yield_node<VisualScriptYield::YIELD_FRAME>);

VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_physics_frame", create_yield_node<VisualScriptYield::YIELD_PHYSICS_FRAME>);

VisualScriptLanguage::singleton->add_register_func("functions/wait/wait_time", create_yield_node<VisualScriptYield::YIELD_WAIT>);