7 files changed, 309 insertions, 56 deletions

diff --git a/modules/visual_script/register_types.cpp b/modules/visual_script/register_types.cpp
index 58afeef3e..0e9710766 100644
--- a/modules/visual_script/register_types.cpp
+++ b/modules/visual_script/register_types.cpp
@@ -60,6 +60,7 @@ void register_visual_script_types() {
 	ObjectTypeDB::register_type<VisualScriptGlobalConstant>();
 	ObjectTypeDB::register_type<VisualScriptClassConstant>();
 	ObjectTypeDB::register_type<VisualScriptMathConstant>();
+	ObjectTypeDB::register_type<VisualScriptBasicTypeConstant>();
 	ObjectTypeDB::register_type<VisualScriptEngineSingleton>();
 	ObjectTypeDB::register_type<VisualScriptSceneNode>();
 	ObjectTypeDB::register_type<VisualScriptSceneTree>();
diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h
index 9e96967c6..fe09e7af4 100644
--- a/modules/visual_script/visual_script.h
+++ b/modules/visual_script/visual_script.h
@@ -38,6 +38,8 @@ public:
 
 	virtual String get_output_sequence_port_text(int p_port) const=0;
 
+	virtual bool has_mixed_input_and_sequence_ports() const { return false; }
+
 	virtual int get_input_value_port_count() const=0;
 	virtual int get_output_value_port_count() const=0;
 
diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp
index 7f09a265f..9f8dfcabc 100644
--- a/modules/visual_script/visual_script_editor.cpp
+++ b/modules/visual_script/visual_script_editor.cpp
@@ -523,19 +523,27 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 		gnode->set_offset(pos*EDSCALE);
 		slot_idx++;
 
+
+		int mixed_seq_ports=0;
+
 		if (!single_seq_output) {
-			for(int i=0;i<node->get_output_sequence_port_count();i++) {
 
-				Label *text2 = memnew( Label );
-				text2->set_text(node->get_output_sequence_port_text(i));
-				text2->set_align(Label::ALIGN_RIGHT);
-				gnode->add_child(text2);
-				gnode->set_slot(slot_idx,false,0,Color(),true,TYPE_SEQUENCE,Color(1,1,1,1),seq_port,seq_port);
-				slot_idx++;
+			if (node->has_mixed_input_and_sequence_ports()) {
+				mixed_seq_ports=node->get_output_sequence_port_count();
+			} else {
+				for(int i=0;i<node->get_output_sequence_port_count();i++) {
+
+					Label *text2 = memnew( Label );
+					text2->set_text(node->get_output_sequence_port_text(i));
+					text2->set_align(Label::ALIGN_RIGHT);
+					gnode->add_child(text2);
+					gnode->set_slot(slot_idx,false,0,Color(),true,TYPE_SEQUENCE,Color(1,1,1,1),seq_port,seq_port);
+					slot_idx++;
+				}
 			}
 		}
 
-		for(int i=0;i<MAX(node->get_output_value_port_count(),node->get_input_value_port_count());i++) {
+		for(int i=0;i<MAX(node->get_output_value_port_count(),MAX(mixed_seq_ports,node->get_input_value_port_count()));i++) {
 
 			bool left_ok=false;
 			Variant::Type left_type=Variant::NIL;
@@ -554,8 +562,8 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 			Variant::Type right_type=Variant::NIL;
 			String right_name;
 
-			if (i<node->get_output_value_port_count()) {
-				PropertyInfo pi = node->get_output_value_port_info(i);
+			if (i>=mixed_seq_ports && i<node->get_output_value_port_count()+mixed_seq_ports) {
+				PropertyInfo pi = node->get_output_value_port_info(i-mixed_seq_ports);
 				right_ok=true;
 				right_type=pi.type;
 				right_name=pi.name;
@@ -620,6 +628,14 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 
 			hbc->add_spacer();
 
+			if (i<mixed_seq_ports) {
+
+				Label *text2 = memnew( Label );
+				text2->set_text(node->get_output_sequence_port_text(i));
+				text2->set_align(Label::ALIGN_RIGHT);
+				hbc->add_child(text2);
+			}
+
 			if (right_ok) {
 
 				hbc->add_child(memnew(Label(right_name)));
@@ -639,7 +655,11 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 
 			gnode->add_child(hbc);
 
-			gnode->set_slot(slot_idx,left_ok,left_type,_color_from_type(left_type),right_ok,right_type,_color_from_type(right_type));
+			if (i<mixed_seq_ports) {
+				gnode->set_slot(slot_idx,left_ok,left_type,_color_from_type(left_type),true,TYPE_SEQUENCE,Color(1,1,1,1),Ref<Texture>(),seq_port);
+			} else {
+				gnode->set_slot(slot_idx,left_ok,left_type,_color_from_type(left_type),right_ok,right_type,_color_from_type(right_type));
+			}
 
 			slot_idx++;
 		}
diff --git a/modules/visual_script/visual_script_flow_control.cpp b/modules/visual_script/visual_script_flow_control.cpp
index 5066a4214..97338da18 100644
--- a/modules/visual_script/visual_script_flow_control.cpp
+++ b/modules/visual_script/visual_script_flow_control.cpp
@@ -616,7 +616,7 @@ bool VisualScriptSwitch::has_input_sequence_port() const{
 int VisualScriptSwitch::get_input_value_port_count() const{
 
 
-	return 1;
+	return case_values.size()+1;
 }
 int VisualScriptSwitch::get_output_value_port_count() const{
 
@@ -628,14 +628,15 @@ String VisualScriptSwitch::get_output_sequence_port_text(int p_port) const {
 	if (p_port==case_values.size())
 		return "done";
 
-	if (case_values[p_port].value.get_type()==Variant::NIL)
-		return "null";
-	return case_values[p_port].value;
+	return String();
 }
 
 PropertyInfo VisualScriptSwitch::get_input_value_port_info(int p_idx) const{
 
-	return PropertyInfo(Variant::NIL,"input");
+	if (p_idx<case_values.size()) {
+		return PropertyInfo(case_values[p_idx].type," =");
+	} else
+		return PropertyInfo(Variant::NIL,"input");
 }
 
 PropertyInfo VisualScriptSwitch::get_output_value_port_info(int p_idx) const{
@@ -659,7 +660,7 @@ class VisualScriptNodeInstanceSwitch : public VisualScriptNodeInstance {
 public:
 
 	VisualScriptInstance* instance;
-	Vector<Variant> case_values;
+	int case_count;
 
 	//virtual int get_working_memory_size() const { return 0; }
 	//virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
@@ -668,17 +669,17 @@ 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_start_mode==START_MODE_CONTINUE_SEQUENCE) {
-			return case_values.size(); //exit
+			return case_count; //exit
 		}
 
-		for(int i=0;i<case_values.size();i++) {
+		for(int i=0;i<case_count;i++) {
 
-			if (*p_inputs[0]==case_values[i]) {
+			if (*p_inputs[i]==*p_inputs[case_count]) {
 				return i|STEP_FLAG_PUSH_STACK_BIT;
 			}
 		}
 
-		return case_values.size();
+		return case_count;
 	}
 
 
@@ -688,10 +689,7 @@ VisualScriptNodeInstance* VisualScriptSwitch::instance(VisualScriptInstance* p_i
 
 	VisualScriptNodeInstanceSwitch * instance = memnew(VisualScriptNodeInstanceSwitch );
 	instance->instance=p_instance;
-	instance->case_values.resize(case_values.size());
-	for(int i=0;i<case_values.size();i++) {
-		instance->case_values[i]=case_values[i].value;
-	}
+	instance->case_count=case_values.size();
 	return instance;
 }
 
@@ -708,23 +706,12 @@ bool VisualScriptSwitch::_set(const StringName& p_name, const Variant& p_value)
 
 		int idx = String(p_name).get_slice("/",1).to_int();
 		ERR_FAIL_INDEX_V(idx,case_values.size(),false);
-		String what = String(p_name).get_slice("/",2);
-
-		if (what=="type") {
-			case_values[idx].type=Variant::Type(int(p_value));
-			Variant::CallError ce;
-			case_values[idx].value=Variant::construct(case_values[idx].type,NULL,0,ce);
-			_change_notify();
-			ports_changed_notify();
 
-			return true;
-		}
+		case_values[idx].type=Variant::Type(int(p_value));
+		_change_notify();
+		ports_changed_notify();
 
-		if (what=="value") {
-			case_values[idx].value=p_value;
-			ports_changed_notify();
-			return true;
-		}
+		return true;
 	}
 
 	return false;
@@ -741,17 +728,9 @@ bool VisualScriptSwitch::_get(const StringName& p_name,Variant &r_ret) const {
 
 		int idx = String(p_name).get_slice("/",1).to_int();
 		ERR_FAIL_INDEX_V(idx,case_values.size(),false);
-		String what = String(p_name).get_slice("/",2);
-
-		if (what=="type") {
-			r_ret=case_values[idx].type;
-			return true;
-		}
 
-		if (what=="value") {
-			r_ret=case_values[idx].value;
-			return true;
-		}
+		r_ret=case_values[idx].type;
+		return true;
 	}
 
 	return false;
@@ -767,8 +746,7 @@ void VisualScriptSwitch::_get_property_list( List<PropertyInfo> *p_list) const {
 	}
 
 	for(int i=0;i<case_values.size();i++) {
-		p_list->push_back(PropertyInfo(Variant::INT,"case/"+itos(i)+"/type",PROPERTY_HINT_ENUM,argt));
-		p_list->push_back(PropertyInfo(case_values[i].type,"case/"+itos(i)+"/value"));
+		p_list->push_back(PropertyInfo(Variant::INT,"case/"+itos(i),PROPERTY_HINT_ENUM,argt));
 	}
 }
 
diff --git a/modules/visual_script/visual_script_flow_control.h b/modules/visual_script/visual_script_flow_control.h
index e1730a226..e0da84a53 100644
--- a/modules/visual_script/visual_script_flow_control.h
+++ b/modules/visual_script/visual_script_flow_control.h
@@ -203,7 +203,6 @@ class VisualScriptSwitch : public VisualScriptNode {
 
 	struct Case {
 		Variant::Type type;
-		Variant value;
 		Case() { type=Variant::NIL; }
 	};
 
@@ -224,6 +223,7 @@ public:
 
 
 	virtual String get_output_sequence_port_text(int p_port) const;
+	virtual bool has_mixed_input_and_sequence_ports() const { return true; }
 
 
 	virtual int get_input_value_port_count() const;
diff --git a/modules/visual_script/visual_script_nodes.cpp b/modules/visual_script/visual_script_nodes.cpp
index f5c5159af..e5436cc26 100644
--- a/modules/visual_script/visual_script_nodes.cpp
+++ b/modules/visual_script/visual_script_nodes.cpp
@@ -1569,6 +1569,151 @@ VisualScriptClassConstant::VisualScriptClassConstant() {
 }
 
 
+//////////////////////////////////////////
+////////////////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(Variant::INT,"value");
+}
+
+
+String VisualScriptBasicTypeConstant::get_caption() const {
+
+	return "BasicConst";
+}
+
+String VisualScriptBasicTypeConstant::get_text() const {
+
+	return Variant::get_type_name(type)+"."+String(name);
+}
+
+void VisualScriptBasicTypeConstant::set_basic_type_constant(const StringName& p_which) {
+
+	name=p_which;
+	_change_notify();
+	ports_changed_notify();
+}
+
+StringName VisualScriptBasicTypeConstant::get_basic_type_constant() const {
+	return name;
+}
+
+
+void VisualScriptBasicTypeConstant::set_basic_type(Variant::Type p_which) {
+
+	type=p_which;
+	_change_notify();
+	ports_changed_notify();
+}
+
+Variant::Type VisualScriptBasicTypeConstant::get_basic_type() const {
+	return type;
+}
+
+class VisualScriptNodeInstanceBasicTypeConstant : public VisualScriptNodeInstance {
+public:
+
+	int value;
+	bool valid;
+	//virtual int get_working_memory_size() const { return 0; }
+
+	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 (!valid) {
+			r_error_str="Invalid constant name, pick a valid basic type constant.";
+			r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		}
+
+		*p_outputs[0] = value;
+		return 0;
+	}
+
+
+};
+
+VisualScriptNodeInstance* VisualScriptBasicTypeConstant::instance(VisualScriptInstance* p_instance) {
+
+	VisualScriptNodeInstanceBasicTypeConstant * instance = memnew(VisualScriptNodeInstanceBasicTypeConstant );
+	instance->value=Variant::get_numeric_constant_value(type,name,&instance->valid);
+	return instance;
+}
+
+void VisualScriptBasicTypeConstant::_validate_property(PropertyInfo& property) const {
+
+	if (property.name=="constant") {
+
+		List<StringName> constants;
+		Variant::get_numeric_constants_for_type(type,&constants);
+
+		if (constants.size()==0) {
+			property.usage=0;
+			return;
+		}
+		property.hint_string="";
+		for(List<StringName>::Element *E=constants.front();E;E=E->next()) {
+			if (property.hint_string!=String()) {
+				property.hint_string+=",";
+			}
+			property.hint_string+=String(E->get());
+		}
+
+	}
+}
+
+void VisualScriptBasicTypeConstant::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_basic_type","name"),&VisualScriptBasicTypeConstant::set_basic_type);
+	ObjectTypeDB::bind_method(_MD("get_basic_type"),&VisualScriptBasicTypeConstant::get_basic_type);
+
+	ObjectTypeDB::bind_method(_MD("set_basic_type_constant","name"),&VisualScriptBasicTypeConstant::set_basic_type_constant);
+	ObjectTypeDB::bind_method(_MD("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),_SCS("set_basic_type"),_SCS("get_basic_type"));
+	ADD_PROPERTY(PropertyInfo(Variant::STRING,"constant",PROPERTY_HINT_ENUM,""),_SCS("set_basic_type_constant"),_SCS("get_basic_type_constant"));
+}
+
+VisualScriptBasicTypeConstant::VisualScriptBasicTypeConstant() {
+
+	type=Variant::NIL;
+}
+
 
 
 //////////////////////////////////////////
@@ -3247,13 +3392,29 @@ PropertyInfo VisualScriptInputAction::get_output_value_port_info(int p_idx) cons
 
 String VisualScriptInputAction::get_caption() const {
 
+
 	return "Action";
 }
 
 
 String VisualScriptInputAction::get_text() const {
 
-	return name;
+	switch(mode) {
+		case MODE_PRESSED: {
+			return name;
+		} break;
+		case MODE_RELEASED: {
+			return "not "+name;
+		} break;
+		case MODE_JUST_PRESSED: {
+			return String(name)+" "+TTR("just pressed");
+		} break;
+		case MODE_JUST_RELEASED: {
+			return String(name)+" "+TTR("just released");
+		} break;
+	}
+
+	return String();
 }
 
 
@@ -3278,19 +3439,50 @@ 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;
 	StringName action;
+	VisualScriptInputAction::Mode mode;
 
 
 	virtual int get_working_memory_size() const { return 1; }
 
 	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_outputs[0]=Input::get_singleton()->is_action_pressed(action);
+		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;
 	}
 
@@ -3302,6 +3494,7 @@ VisualScriptNodeInstance* VisualScriptInputAction::instance(VisualScriptInstance
 	VisualScriptNodeInstanceInputAction * instance = memnew(VisualScriptNodeInstanceInputAction );
 	instance->instance=p_instance;
 	instance->action=name;
+	instance->mode=mode;
 
 	return instance;
 }
@@ -3348,13 +3541,18 @@ 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);
 
+	ObjectTypeDB::bind_method(_MD("set_action_mode","mode"),&VisualScriptInputAction::set_action_mode);
+	ObjectTypeDB::bind_method(_MD("get_action_mode"),&VisualScriptInputAction::get_action_mode);
+
 	ADD_PROPERTY( PropertyInfo(Variant::STRING,"action"),_SCS("set_action_name"),_SCS("get_action_name"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"mode",PROPERTY_HINT_ENUM,"Pressed,Released,JustPressed,JustReleased"),_SCS("set_action_mode"),_SCS("get_action_mode"));
 
 }
 
 VisualScriptInputAction::VisualScriptInputAction() {
 
 	name="";
+	mode=MODE_PRESSED;
 
 }
 
@@ -3593,6 +3791,7 @@ void register_visual_script_nodes() {
 	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>);
diff --git a/modules/visual_script/visual_script_nodes.h b/modules/visual_script/visual_script_nodes.h
index c0ffb17e1..885c73ca3 100644
--- a/modules/visual_script/visual_script_nodes.h
+++ b/modules/visual_script/visual_script_nodes.h
@@ -412,6 +412,48 @@ public:
 	VisualScriptClassConstant();
 };
 
+class VisualScriptBasicTypeConstant : public VisualScriptNode {
+
+	OBJ_TYPE(VisualScriptBasicTypeConstant,VisualScriptNode)
+
+	Variant::Type type;
+	StringName name;
+protected:
+	static void _bind_methods();
+	virtual void _validate_property(PropertyInfo& property) const;
+
+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 "constants"; }
+
+	void set_basic_type_constant(const StringName& p_which);
+	StringName get_basic_type_constant() const;
+
+	void set_basic_type(Variant::Type p_which);
+	Variant::Type get_basic_type() const;
+
+	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
+
+	VisualScriptBasicTypeConstant();
+};
+
+
 
 class VisualScriptMathConstant : public VisualScriptNode {
 
@@ -906,8 +948,16 @@ public:
 class VisualScriptInputAction: public VisualScriptNode {
 
 	OBJ_TYPE(VisualScriptInputAction,VisualScriptNode)
+public:
+	enum Mode {
+		MODE_PRESSED,
+		MODE_RELEASED,
+		MODE_JUST_PRESSED,
+		MODE_JUST_RELEASED,
+	};
 
 	StringName name;
+	Mode mode;
 
 protected:
 
@@ -936,12 +986,15 @@ public:
 	void set_action_name(const StringName& p_name);
 	StringName get_action_name() const;
 
+	void set_action_mode(Mode p_mode);
+	Mode get_action_mode() const;
+
 	virtual VisualScriptNodeInstance* instance(VisualScriptInstance* p_instance);
 
 	VisualScriptInputAction();
 };
 
-
+VARIANT_ENUM_CAST( VisualScriptInputAction::Mode )
 
 class VisualScriptDeconstruct: public VisualScriptNode {