Several all around fixes to visual scripting (in the process of creating demos)

core/globals.cpp

@@ -1332,17 +1332,18 @@ Variant _GLOBAL_DEF( const String& p_var, const Variant& p_default) {
 void Globals::add_singleton(const Singleton &p_singleton) {
 
 	singletons.push_back(p_singleton);
+	singleton_ptrs[p_singleton.name]=p_singleton.ptr;
 }
 
 Object* Globals::get_singleton_object(const String& p_name) const {
 
-	for(const List<Singleton>::Element *E=singletons.front();E;E=E->next()) {
-		if (E->get().name == p_name) {
-			return E->get().ptr;
-		};
-	};
 
-	return NULL;
+	const Map<StringName,Object*>::Element *E=singleton_ptrs.find(p_name);
+	if (!E)
+		return NULL;
+	else
+		return E->get();
+
 };
 
 bool Globals::has_singleton(const String& p_name) const {

core/globals.h

@@ -91,6 +91,7 @@ protected:
 	Error _save_settings_binary(const String& p_file,const Map<String,List<String> > &props,const CustomMap& p_custom=CustomMap());
 
 	List<Singleton> singletons;
+	Map<StringName,Object*> singleton_ptrs;
 
 	Error _save_custom_bnd(const String& p_file);
 

modules/visual_script/register_types.cpp

@@ -68,6 +68,10 @@ void register_visual_script_types() {
 	ObjectTypeDB::register_type<VisualScriptSubCall>();
 	ObjectTypeDB::register_type<VisualScriptComment>();
 	ObjectTypeDB::register_type<VisualScriptConstructor>();
+	ObjectTypeDB::register_type<VisualScriptLocalVar>();
+	ObjectTypeDB::register_type<VisualScriptInputAction>();
+	ObjectTypeDB::register_type<VisualScriptDeconstruct>();
+	ObjectTypeDB::register_type<VisualScriptPreload>();
 
 
 	ObjectTypeDB::register_type<VisualScriptFunctionCall>();

modules/visual_script/visual_script.cpp

@@ -1482,7 +1482,10 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 					//from a node that requires read
 					Function::UnsequencedGet *ug = &f->unsequenced_gets[index];
 
-					bool ok = ug->from->get_output_port_unsequenced(i,&variant_stack[ug->to_stack],working_mem,error_str);
+					Variant* ug_working_mem=ug->from->working_mem_idx>=0 ? &variant_stack[ug->from->working_mem_idx] : (Variant*)NULL;
+
+
+					bool ok = ug->from->get_output_port_unsequenced(i,&variant_stack[ug->to_stack],ug_working_mem,error_str);
 					if (!ok) {
 						r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
 						current_node_id=ug->from->get_id();
@@ -1519,13 +1522,13 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 		{
 			if (p_resuming_yield)
 				start_mode=VisualScriptNodeInstance::START_MODE_RESUME_YIELD;
-			else if (flow_stack && !(flow_stack[flow_stack_pos] & VisualScriptNodeInstance::FLOW_STACK_PUSHED_BIT)) //if there is a push bit, it means we are continuing a sequence
+			else if (!flow_stack || !(flow_stack[flow_stack_pos] & VisualScriptNodeInstance::FLOW_STACK_PUSHED_BIT)) //if there is a push bit, it means we are continuing a sequence
 				start_mode=VisualScriptNodeInstance::START_MODE_BEGIN_SEQUENCE;
 			else
 				start_mode=VisualScriptNodeInstance::START_MODE_CONTINUE_SEQUENCE;
 		}
 
-		VSDEBUG("STEP - STARTSEQ: "+itos(start_sequence));
+		VSDEBUG("STEP - STARTSEQ: "+itos(start_mode));
 
 		int ret = node->step(input_args,output_args,start_mode,working_mem,r_error,error_str);
 
@@ -1734,6 +1737,7 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 						node = instances[ flow_stack[i] & VisualScriptNodeInstance::FLOW_STACK_MASK ];
 						flow_stack_pos=i;
 						found=true;
+						break;
 					}
 				}
 
@@ -1762,6 +1766,22 @@ Variant VisualScriptInstance::_call_internal(const StringName& p_method, void* p
 		String err_func = p_method;
 		int err_line=current_node_id; //not a line but it works as one
 
+		if (node && (r_error.error!=Variant::CallError::CALL_ERROR_INVALID_METHOD || error_str==String())) {
+
+			if (r_error.error==Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
+				int errorarg=r_error.argument;
+				error_str="Cannot convert argument "+itos(errorarg+1)+" to "+Variant::get_type_name(r_error.expected)+".";
+			} else if (r_error.error==Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
+				error_str="Expected "+itos(r_error.argument)+" arguments.";
+			} else if (r_error.error==Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
+				error_str="Expected "+itos(r_error.argument)+" arguments.";
+			} else if (r_error.error==Variant::CallError::CALL_ERROR_INVALID_METHOD) {
+				error_str="Invalid Call.";
+			} else if (r_error.error==Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
+				error_str="Instance is null";
+			}
+		}
+
 
 		//if (!GDScriptLanguage::get_singleton()->debug_break(err_text,false)) {
 			// debugger break did not happen
@@ -1959,6 +1979,7 @@ void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_ow
 		function.max_stack=0;
 		function.flow_stack_size=0;
 		function.node_count=0;
+		Map<StringName,int> local_var_indices;
 
 		if (function.node<0) {
 			VisualScriptLanguage::singleton->debug_break_parse(get_script()->get_path(),0,"No start node in function: "+String(E->key()));
@@ -2022,7 +2043,20 @@ void VisualScriptInstance::create(const Ref<VisualScript>& p_script,Object *p_ow
 				}
 			}
 
-			if (instance->get_working_memory_size()) {
+			if (node->cast_to<VisualScriptLocalVar>()) {
+				//working memory is shared only for this node, for the same variables
+				Ref<VisualScriptLocalVar> vslv = node;
+
+				StringName var_name = String(vslv->get_var_name()).strip_edges();
+
+				if (!local_var_indices.has(var_name)) {
+					local_var_indices[var_name]=function.max_stack;
+					function.max_stack++;
+				}
+
+				instance->working_mem_idx=local_var_indices[var_name];
+
+			} else if (instance->get_working_memory_size()) {
 				instance->working_mem_idx = function.max_stack;
 				function.max_stack+=instance->get_working_memory_size();
 			} else {

modules/visual_script/visual_script_editor.cpp

@@ -1426,6 +1426,8 @@ bool VisualScriptEditor::can_drop_data_fw(const Point2& p_point,const Variant& p
 					String(d["type"])=="visual_script_variable_drag" ||
 					String(d["type"])=="visual_script_signal_drag" ||
 					String(d["type"])=="obj_property" ||
+					String(d["type"])=="resource" ||
+					String(d["type"])=="files" ||
 					String(d["type"])=="nodes"
 				) ) {
 
@@ -1586,13 +1588,14 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			Ref<VisualScriptFunctionCall> vnode;
 			vnode.instance();
 			vnode->set_call_mode(VisualScriptFunctionCall::CALL_MODE_SELF);
-			vnode->set_base_type(script->get_instance_base_type());
-			vnode->set_function(d["function"]);
 
 			int new_id = script->get_available_id();
 
 			undo_redo->create_action(TTR("Add Node"));
 			undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,vnode,ofs);
+			undo_redo->add_do_method(vnode.ptr(),"set_base_type",script->get_instance_base_type());
+			undo_redo->add_do_method(vnode.ptr(),"set_function",d["function"]);
+
 			undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
 			undo_redo->add_do_method(this,"_update_graph");
 			undo_redo->add_undo_method(this,"_update_graph");
@@ -1634,8 +1637,90 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 			if (node) {
 				graph->set_selected(node);
 				_node_selected(node);
+			}			
+		}
+
+		if (d.has("type") && String(d["type"])=="resource") {
+
+			Vector2 ofs = graph->get_scroll_ofs() + p_point;
+			if (graph->is_using_snap()) {
+				int snap = graph->get_snap();
+				ofs = ofs.snapped(Vector2(snap,snap));
+			}
+
+			ofs/=EDSCALE;
+
+			Ref<VisualScriptPreload> prnode;
+			prnode.instance();
+			prnode->set_preload(d["resource"]);
+
+			int new_id = script->get_available_id();
+
+			undo_redo->create_action(TTR("Add Preload Node"));
+			undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,prnode,ofs);
+			undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
+			undo_redo->add_do_method(this,"_update_graph");
+			undo_redo->add_undo_method(this,"_update_graph");
+			undo_redo->commit_action();
+
+			Node* node = graph->get_node(itos(new_id));
+			if (node) {
+				graph->set_selected(node);
+				_node_selected(node);
+			}
+		}
+
+		if (d.has("type") && String(d["type"])=="files") {
+
+			Vector2 ofs = graph->get_scroll_ofs() + p_point;
+			if (graph->is_using_snap()) {
+				int snap = graph->get_snap();
+				ofs = ofs.snapped(Vector2(snap,snap));
+			}
+
+			ofs/=EDSCALE;
+
+			Array files = d["files"];
+
+			List<int> new_ids;
+			int new_id = script->get_available_id();
+
+			if (files.size()) {
+				undo_redo->create_action(TTR("Add Preload Node"));
+
+				for(int i=0;i<files.size();i++) {
+
+					Ref<Resource> res = ResourceLoader::load(files[i]);
+					if (!res.is_valid())
+						continue;
+
+					Ref<VisualScriptPreload> prnode;
+					prnode.instance();
+					prnode->set_preload(res);
+
+					undo_redo->add_do_method(script.ptr(),"add_node",edited_func,new_id,prnode,ofs);
+					undo_redo->add_undo_method(script.ptr(),"remove_node",edited_func,new_id);
+					new_ids.push_back(new_id);
+					new_id++;
+					ofs+=Vector2(20,20)*EDSCALE;
+				}
+
+
+				undo_redo->add_do_method(this,"_update_graph");
+				undo_redo->add_undo_method(this,"_update_graph");
+				undo_redo->commit_action();
+			}
+
+			for(List<int>::Element *E=new_ids.front();E;E=E->next()) {
+
+				Node* node = graph->get_node(itos(E->get()));
+				if (node) {
+					graph->set_selected(node);
+					_node_selected(node);
+				}
 			}
 		}
+
 		if (d.has("type") && String(d["type"])=="nodes") {
 
 			Node* sn = _find_script_node(get_tree()->get_edited_scene_root(),get_tree()->get_edited_scene_root(),script);
@@ -1808,16 +1893,24 @@ void VisualScriptEditor::drop_data_fw(const Point2& p_point,const Variant& p_dat
 
 					Ref<VisualScriptPropertySet> pset;
 					pset.instance();
-					pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_NODE_PATH);
-					pset->set_base_path(sn->get_path_to(node));
+					if (sn==node) {
+						pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_SELF);
+					} else {
+						pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_NODE_PATH);
+						pset->set_base_path(sn->get_path_to(node));
+					}
 
 					vnode=pset;
 				} else {
 
 					Ref<VisualScriptPropertyGet> pget;
 					pget.instance();
-					pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_NODE_PATH);
-					pget->set_base_path(sn->get_path_to(node));
+					if (sn==node) {
+						pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_SELF);
+					} else {
+						pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_NODE_PATH);
+						pget->set_base_path(sn->get_path_to(node));
+					}
 					vnode=pget;
 
 				}

modules/visual_script/visual_script_flow_control.cpp

@@ -86,7 +86,7 @@ void VisualScriptReturn::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_enable_return_value","enable"),&VisualScriptReturn::set_enable_return_value);
 	ObjectTypeDB::bind_method(_MD("is_return_value_enabled"),&VisualScriptReturn::is_return_value_enabled);
 
-	String argt="Variant";
+	String argt="Any";
 	for(int i=1;i<Variant::VARIANT_MAX;i++) {
 		argt+=","+Variant::get_type_name(Variant::Type(i));
 	}
@@ -153,7 +153,7 @@ static Ref<VisualScriptNode> create_return_node(const String& p_name) {
 
 int VisualScriptCondition::get_output_sequence_port_count() const {
 
-	return 2;
+	return 3;
 }
 
 bool VisualScriptCondition::has_input_sequence_port() const{
@@ -174,8 +174,10 @@ String VisualScriptCondition::get_output_sequence_port_text(int p_port) const {
 
 	if (p_port==0)
 		return "true";
-	else
+	else if (p_port==1)
 		return "false";
+	else
+		return "done";
 }
 
 PropertyInfo VisualScriptCondition::get_input_value_port_info(int p_idx) const{
@@ -218,10 +220,12 @@ public:
 
 	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
 
-		if (p_inputs[0]->operator bool())
-			return 0;
+		if (p_start_mode==START_MODE_CONTINUE_SEQUENCE)
+			return 2;
+		else if (p_inputs[0]->operator bool())
+			return 0 | STEP_FLAG_PUSH_STACK_BIT;
 		else
-			return 1;
+			return 1 | STEP_FLAG_PUSH_STACK_BIT;
 	}
 
 
@@ -1662,7 +1666,7 @@ VisualScriptInputFilter::VisualScriptInputFilter() {
 
 
 //////////////////////////////////////////
-////////////////EVENT TYPE FILTER///////////
+////////////////TYPE CAST///////////
 //////////////////////////////////////////
 
 

modules/visual_script/visual_script_flow_control.h

@@ -320,6 +320,9 @@ public:
 	VisualScriptTypeCast();
 };
 
+
+
+
 void register_visual_script_flow_control_nodes();
 
 

modules/visual_script/visual_script_func_nodes.cpp

@@ -4,6 +4,7 @@
 #include "scene/main/node.h"
 #include "visual_script_nodes.h"
 #include "io/resource_loader.h"
+#include "globals.h"
 
 //////////////////////////////////////////
 ////////////////CALL//////////////////////
@@ -121,12 +122,18 @@ int VisualScriptFunctionCall::get_output_value_port_count() const{
 		return returns?1:0;
 
 	} else {
+		int ret;
 		MethodBind *mb = ObjectTypeDB::get_method(_get_base_type(),function);
 		if (mb) {
-			return mb->has_return() ? 1 : 0;
+			ret = mb->has_return() ? 1 : 0;
+		} else
+			ret = 1; //it is assumed that script always returns something
+
+		if (call_mode==CALL_MODE_INSTANCE) {
+			ret++;
 		}
 
-		return 1; //it is assumed that script always returns something
+		return ret;
 	}
 }
 
@@ -197,15 +204,34 @@ PropertyInfo VisualScriptFunctionCall::get_output_value_port_info(int p_idx) con
 		return PropertyInfo(Variant::get_method_return_type(basic_type,function),"");
 	} else {
 
-		MethodBind *mb = ObjectTypeDB::get_method(_get_base_type(),function);
+		if (call_mode==CALL_MODE_INSTANCE) {
+			if (p_idx==0) {
+				return PropertyInfo(Variant::OBJECT,"pass");
+			} else {
+				p_idx--;
+			}
+		}
+
+		PropertyInfo ret;
+
+		/*MethodBind *mb = ObjectTypeDB::get_method(_get_base_type(),function);
 		if (mb) {
 
-			PropertyInfo pi = mb->get_argument_info(-1);
-			pi.name="";
-			return pi;
+			ret = mb->get_argument_info(-1);
+		} else {*/
+
+		ret = method_cache.return_val;
+
+		//}
+
+		if (call_mode==CALL_MODE_INSTANCE) {
+			ret.name="return";
+		} else {
+			ret.name="";
 		}
+		return ret;
+
 
-		return method_cache.return_val;
 	}
 #else
 	return PropertyInfo();
@@ -215,11 +241,12 @@ PropertyInfo VisualScriptFunctionCall::get_output_value_port_info(int p_idx) con
 
 String VisualScriptFunctionCall::get_caption() const {
 
-	static const char*cname[4]= {
+	static const char*cname[5]= {
 		"CallSelf",
 		"CallNode",
 		"CallInstance",
-		"CallBasic"
+		"CallBasic",
+		"CallSingleton"
 	};
 
 	String caption = cname[call_mode];
@@ -235,8 +262,12 @@ String VisualScriptFunctionCall::get_text() const {
 
 	if (call_mode==CALL_MODE_SELF)
 		return "  "+String(function)+"()";
+	if (call_mode==CALL_MODE_SINGLETON)
+		return String(singleton)+":"+String(function)+"()";
 	else if (call_mode==CALL_MODE_BASIC_TYPE)
 		return Variant::get_type_name(basic_type)+"."+String(function)+"()";
+	else if (call_mode==CALL_MODE_NODE_PATH)
+		return " ["+String(base_path.simplified())+"]."+String(function)+"()";
 	else
 		return "  "+base_type+"."+String(function)+"()";
 
@@ -289,6 +320,27 @@ String VisualScriptFunctionCall::get_base_script() const {
 	return base_script;
 }
 
+void VisualScriptFunctionCall::set_singleton(const StringName& p_path) {
+
+	if (singleton==p_path)
+		return;
+
+	singleton=p_path;
+	Object *obj = Globals::get_singleton()->get_singleton_object(singleton);
+	if (obj) {
+		base_type=obj->get_type();
+	}
+
+	_change_notify();
+	ports_changed_notify();
+}
+
+StringName VisualScriptFunctionCall::get_singleton() const {
+
+	return singleton;
+}
+
+
 
 void VisualScriptFunctionCall::_update_method_cache() {
 	StringName type;
@@ -309,6 +361,15 @@ void VisualScriptFunctionCall::_update_method_cache() {
 			base_type=type; //cache, too
 			script=get_visual_script();
 		}
+
+	} else if (call_mode==CALL_MODE_SINGLETON) {
+
+		Object *obj = Globals::get_singleton()->get_singleton_object(singleton);
+		if (obj) {
+			type=obj->get_type();
+			script=obj->get_script();
+		}
+
 	} else if (call_mode==CALL_MODE_INSTANCE) {
 
 		type=base_type;
@@ -475,6 +536,24 @@ void VisualScriptFunctionCall::_validate_property(PropertyInfo& property) const
 		}
 	}
 
+	if (property.name=="function/singleton") {
+		if (call_mode!=CALL_MODE_SINGLETON) {
+			property.usage=0;
+		} else {
+			List<Globals::Singleton> names;
+			Globals::get_singleton()->get_singletons(&names);
+			property.hint=PROPERTY_HINT_ENUM;
+			String sl;
+			for (List<Globals::Singleton>::Element *E=names.front();E;E=E->next()) {
+				if (sl!=String())
+					sl+=",";
+				sl+=E->get().name;
+			}
+			property.hint_string=sl;
+
+		}
+	}
+
 	if (property.name=="function/node_path") {
 		if (call_mode!=CALL_MODE_NODE_PATH) {
 			property.usage=0;
@@ -499,6 +578,17 @@ void VisualScriptFunctionCall::_validate_property(PropertyInfo& property) const
 		} else if (call_mode==CALL_MODE_SELF && get_visual_script().is_valid()) {
 			property.hint=PROPERTY_HINT_METHOD_OF_SCRIPT;
 			property.hint_string=itos(get_visual_script()->get_instance_ID());
+		} else if (call_mode==CALL_MODE_SINGLETON) {
+
+			Object *obj = Globals::get_singleton()->get_singleton_object(singleton);
+			if (obj) {
+				property.hint=PROPERTY_HINT_METHOD_OF_INSTANCE;
+				property.hint_string=itos(obj->get_instance_ID());
+			} else {
+
+				property.hint=PROPERTY_HINT_METHOD_OF_BASE_TYPE;
+				property.hint_string=base_type;//should be cached
+			}
 		} else if (call_mode==CALL_MODE_INSTANCE) {
 			property.hint=PROPERTY_HINT_METHOD_OF_BASE_TYPE;
 			property.hint_string=base_type;
@@ -579,6 +669,9 @@ void VisualScriptFunctionCall::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_basic_type","basic_type"),&VisualScriptFunctionCall::set_basic_type);
 	ObjectTypeDB::bind_method(_MD("get_basic_type"),&VisualScriptFunctionCall::get_basic_type);
 
+	ObjectTypeDB::bind_method(_MD("set_singleton","singleton"),&VisualScriptFunctionCall::set_singleton);
+	ObjectTypeDB::bind_method(_MD("get_singleton"),&VisualScriptFunctionCall::get_singleton);
+
 	ObjectTypeDB::bind_method(_MD("set_function","function"),&VisualScriptFunctionCall::set_function);
 	ObjectTypeDB::bind_method(_MD("get_function"),&VisualScriptFunctionCall::get_function);
 
@@ -618,9 +711,12 @@ void VisualScriptFunctionCall::_bind_methods() {
 		script_ext_hint+="*."+E->get();
 	}
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"function/call_mode",PROPERTY_HINT_ENUM,"Self,Node Path,Instance,Basic Type"),_SCS("set_call_mode"),_SCS("get_call_mode"));
+
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT,"function/call_mode",PROPERTY_HINT_ENUM,"Self,Node Path,Instance,Basic Type,Singleton"),_SCS("set_call_mode"),_SCS("get_call_mode"));
 	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/base_type",PROPERTY_HINT_TYPE_STRING,"Object"),_SCS("set_base_type"),_SCS("get_base_type"));
 	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/base_script",PROPERTY_HINT_FILE,script_ext_hint),_SCS("set_base_script"),_SCS("get_base_script"));
+	ADD_PROPERTY(PropertyInfo(Variant::STRING,"function/singleton"),_SCS("set_singleton"),_SCS("get_singleton"));
 	ADD_PROPERTY(PropertyInfo(Variant::INT,"function/basic_type",PROPERTY_HINT_ENUM,bt),_SCS("set_basic_type"),_SCS("get_basic_type"));
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"function/node_path",PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),_SCS("set_base_path"),_SCS("get_base_path"));
 	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY,"function/argument_cache",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("_set_argument_cache"),_SCS("_get_argument_cache"));
@@ -644,6 +740,7 @@ public:
 	bool returns;
 	VisualScriptFunctionCall::RPCCallMode rpc_mode;
 	StringName function;
+	StringName singleton;
 
 	VisualScriptFunctionCall *node;
 	VisualScriptInstance *instance;
@@ -736,13 +833,37 @@ public:
 						call_rpc(obj,p_inputs+1,input_args-1);
 					}
 				} else if (returns) {
-					*p_outputs[0] = v.call(function,p_inputs+1,input_args,r_error);
+					if (call_mode==VisualScriptFunctionCall::CALL_MODE_INSTANCE) {
+						*p_outputs[1] = v.call(function,p_inputs+1,input_args,r_error);
+					} else {
+						*p_outputs[0] = v.call(function,p_inputs+1,input_args,r_error);
+					}
 				} else {
 					v.call(function,p_inputs+1,input_args,r_error);
 				}
 
+				if (call_mode==VisualScriptFunctionCall::CALL_MODE_INSTANCE) {
+					*p_outputs[0]=*p_inputs[0];
+				}
+
 			} break;
+			case VisualScriptFunctionCall::CALL_MODE_SINGLETON: {
+
+				Object *object=Globals::get_singleton()->get_singleton_object(singleton);
+				if (!object) {
+					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+					r_error_str="Invalid singleton name: '"+String(singleton)+"'";
+					return 0;
+				}
 
+				if (rpc_mode) {
+					call_rpc(object,p_inputs,input_args);
+				} else if (returns) {
+					*p_outputs[0] = object->call(function,p_inputs,input_args,r_error);
+				} else {
+					object->call(function,p_inputs,input_args,r_error);
+				}
+			} break;
 		}
 		return 0;
 
@@ -756,6 +877,7 @@ VisualScriptNodeInstance* VisualScriptFunctionCall::instance(VisualScriptInstanc
 	VisualScriptNodeInstanceFunctionCall * instance = memnew(VisualScriptNodeInstanceFunctionCall );
 	instance->node=this;
 	instance->instance=p_instance;
+	instance->singleton=singleton;
 	instance->function=function;
 	instance->call_mode=call_mode;
 	instance->returns=get_output_value_port_count();
@@ -866,16 +988,13 @@ StringName VisualScriptPropertySet::_get_base_type() const {
 
 int VisualScriptPropertySet::get_input_value_port_count() const{
 
-	int pc = (call_mode==CALL_MODE_BASIC_TYPE || call_mode==CALL_MODE_INSTANCE)?1:0;
-
-	if (!use_builtin_value)
-		pc++;
+	int pc = (call_mode==CALL_MODE_BASIC_TYPE || call_mode==CALL_MODE_INSTANCE)?2:1;
 
 	return pc;
 }
 int VisualScriptPropertySet::get_output_value_port_count() const{
 
-	return call_mode==CALL_MODE_BASIC_TYPE? 1 : 0;
+	return (call_mode==CALL_MODE_BASIC_TYPE || call_mode==CALL_MODE_INSTANCE) ? 1 : 0;
 }
 
 String VisualScriptPropertySet::get_output_sequence_port_text(int p_port) const {
@@ -904,6 +1023,8 @@ PropertyInfo VisualScriptPropertySet::get_input_value_port_info(int p_idx) const
 PropertyInfo VisualScriptPropertySet::get_output_value_port_info(int p_idx) const{
 	if (call_mode==CALL_MODE_BASIC_TYPE) {
 		return PropertyInfo(basic_type,"out");
+	} else if (call_mode==CALL_MODE_INSTANCE) {
+		return PropertyInfo(Variant::OBJECT,"pass");
 	} else {
 		return PropertyInfo();
 	}
@@ -929,18 +1050,12 @@ String VisualScriptPropertySet::get_text() const {
 
 	if (call_mode==CALL_MODE_BASIC_TYPE)
 		prop=Variant::get_type_name(basic_type)+"."+property;
-	else
+	else if (call_mode==CALL_MODE_NODE_PATH)
+		prop=String(base_path)+":"+property;
+	else if (call_mode==CALL_MODE_SELF)
 		prop=property;
-
-	if (use_builtin_value) {
-		String bit = builtin_value.get_construct_string();
-		if (bit.length()>40) {
-			bit=bit.substr(0,40);
-			bit+="...";
-		}
-
-		prop+="\n  "+bit;
-	}
+	else if (call_mode==CALL_MODE_INSTANCE)
+		prop=String(base_type)+":"+property;
 
 	return prop;
 
@@ -1183,35 +1298,6 @@ VisualScriptPropertySet::CallMode VisualScriptPropertySet::get_call_mode() const
 }
 
 
-void VisualScriptPropertySet::set_use_builtin_value(bool p_use) {
-
-	if (use_builtin_value==p_use)
-		return;
-
-	use_builtin_value=p_use;
-	_change_notify();
-	ports_changed_notify();
-
-}
-
-bool VisualScriptPropertySet::is_using_builtin_value() const{
-
-	return use_builtin_value;
-}
-
-void VisualScriptPropertySet::set_builtin_value(const Variant& p_value){
-
-	if (builtin_value==p_value)
-		return;
-
-	builtin_value=p_value;
-	ports_changed_notify();
-
-}
-Variant VisualScriptPropertySet::get_builtin_value() const{
-
-	return builtin_value;
-}
 
 
 void VisualScriptPropertySet::_set_type_cache(const Dictionary &p_type) {
@@ -1308,17 +1394,6 @@ void VisualScriptPropertySet::_validate_property(PropertyInfo& property) const {
 
 	}
 
-	if (property.name=="value/builtin") {
-
-		if (!use_builtin_value) {
-			property.usage=0;
-		} else {
-			property.type=type_cache.type;
-			property.hint=type_cache.hint;
-			property.hint_string=type_cache.hint_string;
-		}
-
-	}
 }
 
 void VisualScriptPropertySet::_bind_methods() {
@@ -1347,11 +1422,7 @@ void VisualScriptPropertySet::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_base_path","base_path"),&VisualScriptPropertySet::set_base_path);
 	ObjectTypeDB::bind_method(_MD("get_base_path"),&VisualScriptPropertySet::get_base_path);
 
-	ObjectTypeDB::bind_method(_MD("set_builtin_value","value"),&VisualScriptPropertySet::set_builtin_value);
-	ObjectTypeDB::bind_method(_MD("get_builtin_value"),&VisualScriptPropertySet::get_builtin_value);
 
-	ObjectTypeDB::bind_method(_MD("set_use_builtin_value","enable"),&VisualScriptPropertySet::set_use_builtin_value);
-	ObjectTypeDB::bind_method(_MD("is_using_builtin_value"),&VisualScriptPropertySet::is_using_builtin_value);
 
 	String bt;
 	for(int i=0;i<Variant::VARIANT_MAX;i++) {
@@ -1389,8 +1460,6 @@ void VisualScriptPropertySet::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::INT,"property/event_type",PROPERTY_HINT_ENUM,et),_SCS("set_event_type"),_SCS("get_event_type"));
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH,"property/node_path",PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE),_SCS("set_base_path"),_SCS("get_base_path"));
 	ADD_PROPERTY(PropertyInfo(Variant::STRING,"property/property"),_SCS("set_property"),_SCS("get_property"));
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"value/use_builtin"),_SCS("set_use_builtin_value"),_SCS("is_using_builtin_value"));
-	ADD_PROPERTY(PropertyInfo(Variant::NIL,"value/builtin"),_SCS("set_builtin_value"),_SCS("get_builtin_value"));
 
 	BIND_CONSTANT( CALL_MODE_SELF );
 	BIND_CONSTANT( CALL_MODE_NODE_PATH);
@@ -1405,8 +1474,6 @@ public:
 	VisualScriptPropertySet::CallMode call_mode;
 	NodePath node_path;
 	StringName property;
-	bool use_builtin;
-	Variant builtin_val;
 
 	VisualScriptPropertySet *node;
 	VisualScriptInstance *instance;
@@ -1428,15 +1495,11 @@ public:
 
 				bool valid;
 
-				if (use_builtin) {
-					object->set(property,builtin_val,&valid);
-				} else {
-					object->set(property,*p_inputs[0],&valid);
-				}
+				object->set(property,*p_inputs[0],&valid);
 
 				if (!valid) {
 					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Invalid index property name.";
+					r_error_str="Invalid set value '"+String(*p_inputs[0])+"' on property '"+String(property)+"' of type "+object->get_type();
 				}
 			} break;
 			case VisualScriptPropertySet::CALL_MODE_NODE_PATH: {
@@ -1457,15 +1520,11 @@ public:
 
 				bool valid;
 
-				if (use_builtin) {
-					another->set(property,builtin_val,&valid);
-				} else {
-					another->set(property,*p_inputs[0],&valid);
-				}
+				another->set(property,*p_inputs[0],&valid);
 
 				if (!valid) {
 					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Invalid index property name.";
+					r_error_str="Invalid set value '"+String(*p_inputs[0])+"' on property '"+String(property)+"' of type "+another->get_type();
 				}
 
 			} break;
@@ -1476,20 +1535,14 @@ public:
 
 				bool valid;
 
-				if (use_builtin) {
-					v.set(property,builtin_val,&valid);
-				} else {
-					v.set(property,p_inputs[1],&valid);
-				}
+				v.set(property,*p_inputs[1],&valid);
 
 				if (!valid) {
-					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
-					r_error_str="Invalid index property name.";
+					r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;					
+					r_error_str="Invalid set value '"+String(*p_inputs[1])+"' ("+Variant::get_type_name(p_inputs[1]->get_type())+") on property '"+String(property)+"' of type "+Variant::get_type_name(v.get_type());
 				}
 
-				if (call_mode==VisualScriptPropertySet::CALL_MODE_BASIC_TYPE) {
-					*p_outputs[0]=v;
-				}
+				*p_outputs[0]=v;
 
 			} break;
 
@@ -1509,8 +1562,6 @@ VisualScriptNodeInstance* VisualScriptPropertySet::instance(VisualScriptInstance
 	instance->property=property;
 	instance->call_mode=call_mode;
 	instance->node_path=base_path;
-	instance->use_builtin=use_builtin_value;
-	instance->builtin_val=builtin_value;
 	return instance;
 }
 
@@ -1666,12 +1717,18 @@ String VisualScriptPropertyGet::get_caption() const {
 
 String VisualScriptPropertyGet::get_text() const {
 
+	String prop;
 
 	if (call_mode==CALL_MODE_BASIC_TYPE)
-		return Variant::get_type_name(basic_type)+"."+property;
-	else
-		return property;
+		prop=Variant::get_type_name(basic_type)+"."+property;
+	else if (call_mode==CALL_MODE_NODE_PATH)
+		prop=String(base_path)+":"+property;
+	else if (call_mode==CALL_MODE_SELF)
+		prop=property;
+	else if (call_mode==CALL_MODE_INSTANCE)
+		prop=String(base_type)+":"+property;
 
+	return prop;
 }
 
 void VisualScriptPropertyGet::set_base_type(const StringName& p_type) {

modules/visual_script/visual_script_func_nodes.h

@@ -13,6 +13,7 @@ public:
 		CALL_MODE_NODE_PATH,
 		CALL_MODE_INSTANCE,
 		CALL_MODE_BASIC_TYPE,
+		CALL_MODE_SINGLETON,
 	};
 
 	enum RPCCallMode {
@@ -33,6 +34,7 @@ private:
 	StringName function;
 	int use_default_args;
 	RPCCallMode rpc_call_mode;
+	StringName singleton;
 
 
 	Node *_get_base_node() const;
@@ -78,12 +80,16 @@ public:
 	void set_base_script(const String& p_path);
 	String get_base_script() const;
 
+	void set_singleton(const StringName& p_type);
+	StringName get_singleton() const;
+
 	void set_function(const StringName& p_type);
 	StringName get_function() const;
 
 	void set_base_path(const NodePath& p_type);
 	NodePath get_base_path() const;
 
+
 	void set_call_mode(CallMode p_mode);
 	CallMode get_call_mode() const;
 
@@ -124,8 +130,6 @@ private:
 	String base_script;
 	NodePath base_path;
 	StringName property;
-	bool use_builtin_value;
-	Variant builtin_value;
 	InputEvent::Type event_type;
 
 	Node *_get_base_node() const;
@@ -185,11 +189,6 @@ public:
 	void set_call_mode(CallMode p_mode);
 	CallMode get_call_mode() const;
 
-	void set_use_builtin_value(bool p_use);
-	bool is_using_builtin_value() const;
-
-	void set_builtin_value(const Variant &p_value);
-	Variant get_builtin_value() const;
 
 	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
 

modules/visual_script/visual_script_nodes.cpp

@@ -4,6 +4,7 @@
 #include "scene/main/scene_main_loop.h"
 #include "os/os.h"
 #include "scene/main/node.h"
+#include "os/input.h"
 
 //////////////////////////////////////////
 ////////////////FUNCTION//////////////////
@@ -116,7 +117,7 @@ void  VisualScriptFunction::_get_property_list( List<PropertyInfo> *p_list) cons
 
 
 	p_list->push_back(PropertyInfo(Variant::INT,"argument_count",PROPERTY_HINT_RANGE,"0,256"));
-	String argt="Variant";
+	String argt="Any";
 	for(int i=1;i<Variant::VARIANT_MAX;i++) {
 		argt+=","+Variant::get_type_name(Variant::Type(i));
 	}
@@ -385,6 +386,8 @@ PropertyInfo VisualScriptOperator::get_input_value_port_info(int p_idx) const{
 	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{
@@ -423,6 +426,8 @@ PropertyInfo VisualScriptOperator::get_output_value_port_info(int p_idx) const{
 	PropertyInfo pinfo;
 	pinfo.name="";
 	pinfo.type=port_types[op];
+	if (pinfo.type==Variant::NIL)
+		pinfo.type=typed;
 	return pinfo;
 
 }
@@ -515,19 +520,43 @@ 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() {
 
 	ObjectTypeDB::bind_method(_MD("set_operator","op"),&VisualScriptOperator::set_operator);
 	ObjectTypeDB::bind_method(_MD("get_operator"),&VisualScriptOperator::get_operator);
 
+	ObjectTypeDB::bind_method(_MD("set_typed","type"),&VisualScriptOperator::set_typed);
+	ObjectTypeDB::bind_method(_MD("get_typed"),&VisualScriptOperator::get_typed);
+
 	String types;
 	for(int i=0;i<Variant::OP_MAX;i++) {
 		if (i>0)
 			types+=",";
 		types+=op_names[i];
 	}
-	ADD_PROPERTY(PropertyInfo(Variant::INT,"operator_value/type",PROPERTY_HINT_ENUM,types),_SCS("set_operator"),_SCS("get_operator"));
+
+	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_value/type",PROPERTY_HINT_ENUM,types,PROPERTY_USAGE_NOEDITOR),_SCS("set_operator"),_SCS("get_operator"));
+	ADD_PROPERTY(PropertyInfo(Variant::INT,"typed_value/typed",PROPERTY_HINT_ENUM,argt),_SCS("set_typed"),_SCS("get_typed"));
 
 }
 
@@ -581,6 +610,7 @@ VisualScriptNodeInstance* VisualScriptOperator::instance(VisualScriptInstance* p
 VisualScriptOperator::VisualScriptOperator() {
 
 	op=Variant::OP_ADD;
+	typed=Variant::NIL;
 }
 
 
@@ -1024,6 +1054,125 @@ VisualScriptConstant::VisualScriptConstant() {
 
 }
 
+//////////////////////////////////////////
+////////////////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{
+
+	return PropertyInfo(Variant::OBJECT,"res");
+}
+
+
+String VisualScriptPreload::get_caption() const {
+
+	return "Preload";
+}
+
+String VisualScriptPreload::get_text() const {
+
+	if (preload.is_valid()) {
+		if (preload->get_path().is_resource_file()) {
+			return preload->get_path();
+		} else if (preload->get_name()!=String()) {
+			return preload->get_name();
+		} else {
+			return preload->get_type();
+		}
+	} else {
+		return "<empty>";
+	}
+}
+
+
+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() {
+
+
+	ObjectTypeDB::bind_method(_MD("set_preload","resource"),&VisualScriptPreload::set_preload);
+	ObjectTypeDB::bind_method(_MD("get_preload"),&VisualScriptPreload::get_preload);
+
+
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT,"resource",PROPERTY_HINT_RESOURCE_TYPE,"Resource"),_SCS("set_preload"),_SCS("get_preload"));
+
+}
+
+class VisualScriptNodeInstancePreload : public VisualScriptNodeInstance {
+public:
+
+	Ref<Resource> preload;
+	//virtual int get_working_memory_size() const { return 0; }
+	virtual bool is_output_port_unsequenced(int p_idx) const { return true; }
+	virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const {
+
+		*r_value=preload;
+
+		return true;
+
+	}
+
+	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+
+		return 0;
+	}
+
+
+};
+
+VisualScriptNodeInstance* VisualScriptPreload::instance(VisualScriptInstance* p_instance) {
+
+	VisualScriptNodeInstancePreload * instance = memnew(VisualScriptNodeInstancePreload );
+	instance->preload=preload;
+	return instance;
+}
+
+VisualScriptPreload::VisualScriptPreload() {
+
+}
+
+
 
 
 //////////////////////////////////////////
@@ -2751,6 +2900,519 @@ static Ref<VisualScriptNode> create_constructor_node(const String& p_name) {
 	return vsc;
 }
 
+//////////////////////////////////////////
+////////////////LocalVar///////////
+//////////////////////////////////////////
+
+int VisualScriptLocalVar::get_output_sequence_port_count() const {
+
+	return 1;
+}
+
+bool VisualScriptLocalVar::has_input_sequence_port() const{
+
+	return true;
+}
+
+int VisualScriptLocalVar::get_input_value_port_count() const{
+	return 1;
+}
+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(type,"set");
+}
+PropertyInfo VisualScriptLocalVar::get_output_value_port_info(int p_idx) const{
+
+	return PropertyInfo(type,"get");
+}
+
+
+String VisualScriptLocalVar::get_caption() const {
+
+	return "LocalVar";
+}
+
+
+String VisualScriptLocalVar::get_text() const {
+
+	return name;
+}
+
+
+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;
+	StringName name;
+
+
+	virtual int get_working_memory_size() const { return 1; }
+	virtual bool is_output_port_unsequenced(int p_idx) const { return true; }
+	virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const {
+		*r_value=*p_working_mem;
+		return true;
+	}
+
+	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+
+		*p_working_mem=*p_inputs[0];
+		*p_outputs[0]=*p_working_mem;
+		return 0;
+	}
+
+
+};
+
+VisualScriptNodeInstance* VisualScriptLocalVar::instance(VisualScriptInstance* p_instance) {
+
+	VisualScriptNodeInstanceLocalVar * instance = memnew(VisualScriptNodeInstanceLocalVar );
+	instance->instance=p_instance;
+	instance->name=name;
+
+	return instance;
+}
+
+
+
+void VisualScriptLocalVar::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_var_name","name"),&VisualScriptLocalVar::set_var_name);
+	ObjectTypeDB::bind_method(_MD("get_var_name"),&VisualScriptLocalVar::get_var_name);
+
+	ObjectTypeDB::bind_method(_MD("set_var_type","type"),&VisualScriptLocalVar::set_var_type);
+	ObjectTypeDB::bind_method(_MD("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,"variable/name"),_SCS("set_var_name"),_SCS("get_var_name"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"variable/type",PROPERTY_HINT_ENUM,argt),_SCS("set_var_type"),_SCS("get_var_type"));
+
+
+}
+
+VisualScriptLocalVar::VisualScriptLocalVar() {
+
+	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{
+
+	return PropertyInfo(Variant::BOOL,"pressed");
+}
+
+
+String VisualScriptInputAction::get_caption() const {
+
+	return "Action";
+}
+
+
+String VisualScriptInputAction::get_text() const {
+
+	return 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;
+}
+
+
+class VisualScriptNodeInstanceInputAction : public VisualScriptNodeInstance {
+public:
+
+	VisualScriptInstance* instance;
+	StringName action;
+
+
+	virtual int get_working_memory_size() const { return 1; }
+	virtual bool is_output_port_unsequenced(int p_idx) const { return true; }
+	virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const {
+		*r_value=Input::get_singleton()->is_action_pressed(action);
+		return true;
+	}
+
+	virtual int step(const Variant** p_inputs,Variant** p_outputs,StartMode p_start_mode,Variant* p_working_mem,Variant::CallError& r_error,String& r_error_str) {
+
+		return 0;
+	}
+
+
+};
+
+VisualScriptNodeInstance* VisualScriptInputAction::instance(VisualScriptInstance* p_instance) {
+
+	VisualScriptNodeInstanceInputAction * instance = memnew(VisualScriptNodeInstanceInputAction );
+	instance->instance=p_instance;
+	instance->action=name;
+
+	return instance;
+}
+
+void VisualScriptInputAction::_validate_property(PropertyInfo& property) const {
+
+
+	if (property.name=="action") {
+
+		property.hint=PROPERTY_HINT_ENUM;
+		String actions;
+
+		List<PropertyInfo> pinfo;
+		Globals::get_singleton()->get_property_list(&pinfo);
+		Vector<String> al;
+
+		for(List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
+			const PropertyInfo &pi=E->get();
+
+			if (!pi.name.begins_with("input/"))
+				continue;
+
+			String name = pi.name.substr(pi.name.find("/")+1,pi.name.length());
+
+
+			al.push_back(name);
+		}
+
+		al.sort();;
+
+		for(int i=0;i<al.size();i++) {
+			if (actions!=String())
+				actions+=",";
+			actions+=al[i];
+		}
+
+		property.hint_string=actions;
+	}
+}
+
+
+void VisualScriptInputAction::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_action_name","name"),&VisualScriptInputAction::set_action_name);
+	ObjectTypeDB::bind_method(_MD("get_action_name"),&VisualScriptInputAction::get_action_name);
+
+	ADD_PROPERTY( PropertyInfo(Variant::STRING,"action"),_SCS("set_action_name"),_SCS("get_action_name"));
+
+}
+
+VisualScriptInputAction::VisualScriptInputAction() {
+
+	name="";
+
+}
+
+//////////////////////////////////////////
+////////////////Constructor///////////
+//////////////////////////////////////////
+
+int VisualScriptDeconstruct::get_output_sequence_port_count() const {
+
+	return 1;
+}
+
+bool VisualScriptDeconstruct::has_input_sequence_port() const{
+
+	return true;
+}
+
+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 "Deconstruct";
+}
+
+
+String VisualScriptDeconstruct::get_text() const {
+
+	return "from "+Variant::get_type_name(type)+":";
+}
+
+
+String VisualScriptDeconstruct::get_category() const {
+
+	return "functions";
+}
+
+void VisualScriptDeconstruct::_update_elements() {
+
+	elements.clear();;
+	Variant v;
+	if (type==Variant::INPUT_EVENT) {
+		InputEvent ie;
+		ie.type=input_type;
+		v=ie;
+	} else {
+		Variant::CallError ce;
+		v = Variant::construct(type,NULL,0,ce);
+	}
+
+	List<PropertyInfo> pinfo;
+	v.get_property_list(&pinfo);
+
+	for (List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
+
+		Element e;
+		e.name=E->get().name;
+		e.type=E->get().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();
+	_change_notify(); //to make input appear/disappear
+}
+
+Variant::Type VisualScriptDeconstruct::get_deconstruct_type() const {
+
+	return type;
+}
+
+void VisualScriptDeconstruct::set_deconstruct_input_type(InputEvent::Type p_input_type) {
+
+	if (input_type==p_input_type)
+		return;
+
+	input_type=p_input_type;
+	_update_elements();
+	ports_changed_notify();
+}
+
+InputEvent::Type VisualScriptDeconstruct::get_deconstruct_input_type() const {
+
+	return input_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[i].name=p_elements[i*2+0];
+		elements[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;
+	Vector<StringName> outputs;
+
+	//virtual int get_working_memory_size() const { return 0; }
+	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
+	//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,Variant::CallError& r_error,String& r_error_str) {
+
+		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=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+				return 0;
+			}
+
+		}
+
+		return 0;
+	}
+
+
+};
+
+VisualScriptNodeInstance* VisualScriptDeconstruct::instance(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[i]=elements[i].name;
+	}
+
+	return instance;
+}
+
+
+
+void VisualScriptDeconstruct::_validate_property(PropertyInfo& property) const {
+
+	if (property.name=="input_type") {
+		if (type!=Variant::INPUT_EVENT) {
+			property.usage=0;
+		}
+	}
+}
+
+
+void VisualScriptDeconstruct::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_deconstruct_type","type"),&VisualScriptDeconstruct::set_deconstruct_type);
+	ObjectTypeDB::bind_method(_MD("get_deconstruct_type"),&VisualScriptDeconstruct::get_deconstruct_type);
+
+	ObjectTypeDB::bind_method(_MD("set_deconstruct_input_type","input_type"),&VisualScriptDeconstruct::set_deconstruct_input_type);
+	ObjectTypeDB::bind_method(_MD("get_deconstruct_input_type"),&VisualScriptDeconstruct::get_deconstruct_input_type);
+
+	ObjectTypeDB::bind_method(_MD("_set_elem_cache","_cache"),&VisualScriptDeconstruct::_set_elem_cache);
+	ObjectTypeDB::bind_method(_MD("_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));
+	}
+
+	String iet="None,Key,MouseMotion,MouseButton,JoystickMotion,JoystickButton,ScreenTouch,ScreenDrag,Action";
+
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"type",PROPERTY_HINT_ENUM,argt),_SCS("set_deconstruct_type"),_SCS("get_deconstruct_type"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"input_type",PROPERTY_HINT_ENUM,iet),_SCS("set_deconstruct_input_type"),_SCS("get_deconstruct_input_type"));
+	ADD_PROPERTY( PropertyInfo(Variant::ARRAY,"elem_cache",PROPERTY_HINT_NONE,"",PROPERTY_USAGE_NOEDITOR),_SCS("_set_elem_cache"),_SCS("_get_elem_cache"));
+
+}
+
+VisualScriptDeconstruct::VisualScriptDeconstruct() {
+
+	type=Variant::NIL;
+	input_type=InputEvent::NONE;
+
+}
 
 
 void register_visual_script_nodes() {
@@ -2768,6 +3430,9 @@ void register_visual_script_nodes() {
 	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("data/comment",create_node_generic<VisualScriptComment>);
+	VisualScriptLanguage::singleton->add_register_func("data/local_var",create_node_generic<VisualScriptLocalVar>);
+	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("index/get_index",create_node_generic<VisualScriptIndexGet>);
@@ -2802,6 +3467,7 @@ void register_visual_script_nodes() {
 	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("functions/deconstruct",create_node_generic<VisualScriptDeconstruct>);
 
 	for(int i=1;i<Variant::VARIANT_MAX;i++) {
 

modules/visual_script/visual_script_nodes.h

@@ -75,6 +75,7 @@ class VisualScriptOperator : public VisualScriptNode {
 	OBJ_TYPE(VisualScriptOperator,VisualScriptNode)
 
 
+	Variant::Type typed;
 	Variant::Operator op;
 protected:
 
@@ -102,6 +103,9 @@ public:
 	void set_operator(Variant::Operator p_op);
 	Variant::Operator get_operator() const;
 
+	void set_typed(Variant::Type p_op);
+	Variant::Type get_typed() const;
+
 	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
 
 	VisualScriptOperator();
@@ -229,6 +233,45 @@ public:
 };
 
 
+
+class VisualScriptPreload : public VisualScriptNode {
+
+	OBJ_TYPE(VisualScriptPreload,VisualScriptNode)
+
+
+	Ref<Resource> preload;
+protected:
+
+	static void _bind_methods();
+
+public:
+
+	virtual int get_output_sequence_port_count() const;
+	virtual bool has_input_sequence_port() const;
+
+
+	virtual String get_output_sequence_port_text(int p_port) const;
+
+
+	virtual int get_input_value_port_count() const;
+	virtual int get_output_value_port_count() const;
+
+
+	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
+	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
+
+	virtual String get_caption() const;
+	virtual String get_text() const;
+	virtual String get_category() const { return "data"; }
+
+	void set_preload(const Ref<Resource>& p_value);
+	Ref<Resource> get_preload() const;
+
+	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+
+	VisualScriptPreload();
+};
+
 class VisualScriptIndexGet : public VisualScriptNode {
 
 	OBJ_TYPE(VisualScriptIndexGet,VisualScriptNode)
@@ -702,7 +745,6 @@ class VisualScriptConstructor: public VisualScriptNode {
 
 protected:
 
-	virtual bool _use_builtin_script() const { return true; }
 
 	static void _bind_methods();
 public:
@@ -735,6 +777,149 @@ public:
 	VisualScriptConstructor();
 };
 
+
+
+
+class VisualScriptLocalVar: public VisualScriptNode {
+
+	OBJ_TYPE(VisualScriptLocalVar,VisualScriptNode)
+
+	StringName name;
+	Variant::Type type;
+
+protected:
+
+	static void _bind_methods();
+public:
+	virtual int get_output_sequence_port_count() const;
+	virtual bool has_input_sequence_port() const;
+
+
+	virtual String get_output_sequence_port_text(int p_port) const;
+
+
+	virtual int get_input_value_port_count() const;
+	virtual int get_output_value_port_count() const;
+
+
+	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
+	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
+
+	virtual String get_caption() const;
+	virtual String get_text() const;
+	virtual String get_category() const;
+
+	void set_var_name(const StringName& p_name);
+	StringName get_var_name() const;
+
+	void set_var_type(Variant::Type p_type);
+	Variant::Type get_var_type() const;
+
+	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+
+	VisualScriptLocalVar();
+};
+
+
+
+
+class VisualScriptInputAction: public VisualScriptNode {
+
+	OBJ_TYPE(VisualScriptInputAction,VisualScriptNode)
+
+	StringName name;
+
+protected:
+
+	virtual void _validate_property(PropertyInfo& property) const;
+
+	static void _bind_methods();
+public:
+	virtual int get_output_sequence_port_count() const;
+	virtual bool has_input_sequence_port() const;
+
+
+	virtual String get_output_sequence_port_text(int p_port) const;
+
+
+	virtual int get_input_value_port_count() const;
+	virtual int get_output_value_port_count() const;
+
+
+	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
+	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
+
+	virtual String get_caption() const;
+	virtual String get_text() const;
+	virtual String get_category() const;
+
+	void set_action_name(const StringName& p_name);
+	StringName get_action_name() const;
+
+	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+
+	VisualScriptInputAction();
+};
+
+
+
+class VisualScriptDeconstruct: public VisualScriptNode {
+
+	OBJ_TYPE(VisualScriptDeconstruct,VisualScriptNode)
+
+
+	struct Element {
+		StringName name;
+		Variant::Type type;
+	};
+
+
+	Vector<Element> elements;
+
+	void _update_elements();
+	Variant::Type type;
+	InputEvent::Type input_type;
+
+	void _set_elem_cache(const Array& p_elements);
+	Array _get_elem_cache() const;
+
+	virtual void _validate_property(PropertyInfo& property) const;
+
+protected:
+
+
+	static void _bind_methods();
+public:
+	virtual int get_output_sequence_port_count() const;
+	virtual bool has_input_sequence_port() const;
+
+
+	virtual String get_output_sequence_port_text(int p_port) const;
+
+
+	virtual int get_input_value_port_count() const;
+	virtual int get_output_value_port_count() const;
+
+
+	virtual PropertyInfo get_input_value_port_info(int p_idx) const;
+	virtual PropertyInfo get_output_value_port_info(int p_idx) const;
+
+	virtual String get_caption() const;
+	virtual String get_text() const;
+	virtual String get_category() const;
+
+	void set_deconstruct_type(Variant::Type p_type);
+	Variant::Type get_deconstruct_type() const;
+
+	void set_deconstruct_input_type(InputEvent::Type p_input_type);
+	InputEvent::Type get_deconstruct_input_type() const;
+
+	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+
+	VisualScriptDeconstruct();
+};
+
+
 void register_visual_script_nodes();
 void unregister_visual_script_nodes();
 

scene/2d/physics_body_2d.cpp

@@ -1226,6 +1226,73 @@ Vector2 KinematicBody2D::move(const Vector2& p_motion) {
 #endif
 }
 
+
+
+Vector2 KinematicBody2D::move_and_slide(const Vector2& p_linear_velocity,const Vector2& p_floor_direction,int p_max_bounces) {
+
+	Vector2 motion = p_linear_velocity*get_fixed_process_delta_time();
+	Vector2 lv = p_linear_velocity;
+
+	move_and_slide_on_floor=false;
+	move_and_slide_on_ceiling=false;
+	move_and_slide_on_wall=false;
+	move_and_slide_colliders.clear();
+
+	while(motion!=Vector2() && p_max_bounces) {
+
+		motion=move(motion);
+
+		if (is_colliding()) {
+
+			if (p_floor_direction==Vector2()) {
+				//all is a wall
+				move_and_slide_on_wall=true;
+			} else {
+				if ( get_collision_normal().dot(p_floor_direction) > Math::cos(Math::deg2rad(45))) { //floor
+					move_and_slide_on_floor=true;
+					move_and_slide_floor_velocity=get_collider_velocity();
+				} else if ( get_collision_normal().dot(p_floor_direction) < Math::cos(Math::deg2rad(45))) { //ceiling
+					move_and_slide_on_ceiling=true;
+				} else {
+					move_and_slide_on_wall=true;
+				}
+
+			}
+
+			motion=get_collision_normal().slide(motion);
+			lv=get_collision_normal().slide(lv);
+			Variant collider = _get_collider();
+			if (collider.get_type()!=Variant::NIL) {
+				move_and_slide_colliders.push_back(collider);
+			}
+
+		} else {
+			break;
+		}
+
+		p_max_bounces--;
+	}
+
+	return lv;
+}
+
+bool KinematicBody2D::is_move_and_slide_on_floor() const {
+
+	return move_and_slide_on_floor;
+}
+bool KinematicBody2D::is_move_and_slide_on_wall() const{
+
+	return move_and_slide_on_wall;
+}
+bool KinematicBody2D::is_move_and_slide_on_ceiling() const{
+
+	return move_and_slide_on_ceiling;
+}
+Array KinematicBody2D::get_move_and_slide_colliders() const{
+
+	return move_and_slide_colliders;
+}
+
 Vector2 KinematicBody2D::move_to(const Vector2& p_position) {
 
 	return move(p_position-get_global_pos());
@@ -1300,6 +1367,7 @@ void KinematicBody2D::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("move","rel_vec"),&KinematicBody2D::move);
 	ObjectTypeDB::bind_method(_MD("move_to","position"),&KinematicBody2D::move_to);
+	ObjectTypeDB::bind_method(_MD("move_and_slide","linear_velocity","floor_normal","max_bounces"),&KinematicBody2D::move_and_slide,DEFVAL(Vector2(0,0)),DEFVAL(4));
 
 	ObjectTypeDB::bind_method(_MD("test_move","rel_vec"),&KinematicBody2D::test_move);
 	ObjectTypeDB::bind_method(_MD("get_travel"),&KinematicBody2D::get_travel);
@@ -1313,6 +1381,10 @@ void KinematicBody2D::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_collider:Object"),&KinematicBody2D::_get_collider);
 	ObjectTypeDB::bind_method(_MD("get_collider_shape"),&KinematicBody2D::get_collider_shape);
 	ObjectTypeDB::bind_method(_MD("get_collider_metadata:Variant"),&KinematicBody2D::get_collider_metadata);
+	ObjectTypeDB::bind_method(_MD("get_move_and_slide_colliders"),&KinematicBody2D::get_move_and_slide_colliders);
+	ObjectTypeDB::bind_method(_MD("is_move_and_slide_on_floor"),&KinematicBody2D::is_move_and_slide_on_floor);
+	ObjectTypeDB::bind_method(_MD("is_move_and_slide_on_ceiling"),&KinematicBody2D::is_move_and_slide_on_ceiling);
+	ObjectTypeDB::bind_method(_MD("is_move_and_slide_on_wall"),&KinematicBody2D::is_move_and_slide_on_wall);
 
 	ObjectTypeDB::bind_method(_MD("set_collision_margin","pixels"),&KinematicBody2D::set_collision_margin);
 	ObjectTypeDB::bind_method(_MD("get_collision_margin","pixels"),&KinematicBody2D::get_collision_margin);
@@ -1330,6 +1402,11 @@ KinematicBody2D::KinematicBody2D() : PhysicsBody2D(Physics2DServer::BODY_MODE_KI
 	collider_shape=0;
 
 	margin=0.08;
+
+	move_and_slide_on_floor=false;
+	move_and_slide_on_ceiling=false;
+	move_and_slide_on_wall=false;
+
 }
 KinematicBody2D::~KinematicBody2D()  {
 

scene/2d/physics_body_2d.h

@@ -302,6 +302,12 @@ class KinematicBody2D : public PhysicsBody2D {
 	Variant collider_metadata;
 	Vector2 travel;
 
+	Vector2 move_and_slide_floor_velocity;
+	bool move_and_slide_on_floor;
+	bool move_and_slide_on_ceiling;
+	bool move_and_slide_on_wall;
+	Array move_and_slide_colliders;
+
 	Variant _get_collider() const;
 
 	_FORCE_INLINE_ bool _ignores_mode(Physics2DServer::BodyMode) const;
@@ -329,6 +335,13 @@ public:
 	void set_collision_margin(float p_margin);
 	float get_collision_margin() const;
 
+	Vector2 move_and_slide(const Vector2& p_linear_velocity,const Vector2& p_floor_direction=Vector2(0,0),int p_max_bounces=4);
+	bool is_move_and_slide_on_floor() const;
+	bool is_move_and_slide_on_wall() const;
+	bool is_move_and_slide_on_ceiling() const;
+	Array get_move_and_slide_colliders() const;
+
+
 	KinematicBody2D();
 	~KinematicBody2D();