Ability to reload scripts on running game

4 files changed, 206 insertions, 15 deletions

diff --git a/modules/gdscript/gd_compiler.cpp b/modules/gdscript/gd_compiler.cpp
index 5a6299bcf8..7a2e9c9638 100644
--- a/modules/gdscript/gd_compiler.cpp
+++ b/modules/gdscript/gd_compiler.cpp
@@ -1414,8 +1414,13 @@ Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode *
 
 
 
-Error GDCompiler::_parse_class(GDScript *p_script,GDScript *p_owner,const GDParser::ClassNode *p_class) {
+Error GDCompiler::_parse_class(GDScript *p_script, GDScript *p_owner, const GDParser::ClassNode *p_class, bool p_keep_state) {
 
+	Map<StringName,Ref<GDScript> > old_subclasses;
+
+	if (p_keep_state) {
+		old_subclasses=p_script->subclasses;
+	}
 
 	p_script->native=Ref<GDNativeClass>();
 	p_script->base=Ref<GDScript>();
@@ -1429,6 +1434,7 @@ Error GDCompiler::_parse_class(GDScript *p_script,GDScript *p_owner,const GDPars
 	p_script->member_indices.clear();
 	p_script->member_info.clear();
 	p_script->initializer=NULL;
+
 	p_script->subclasses.clear();
 	p_script->_owner=p_owner;
 	p_script->tool=p_class->tool;
@@ -1662,9 +1668,15 @@ Error GDCompiler::_parse_class(GDScript *p_script,GDScript *p_owner,const GDPars
 	for(int i=0;i<p_class->subclasses.size();i++) {
 		StringName name = p_class->subclasses[i]->name;
 
-		Ref<GDScript> subclass = memnew( GDScript );
+		Ref<GDScript> subclass;
+
+		if (old_subclasses.has(name)) {
+			subclass=old_subclasses[name];
+		} else {
+			subclass.instance();
+		}
 
-		Error err = _parse_class(subclass.ptr(),p_script,p_class->subclasses[i]);
+		Error err = _parse_class(subclass.ptr(),p_script,p_class->subclasses[i],p_keep_state);
 		if (err)
 			return err;
 
@@ -1755,13 +1767,65 @@ Error GDCompiler::_parse_class(GDScript *p_script,GDScript *p_owner,const GDPars
 
 		}
 	}
+
+	//validate instances if keeping state
+
+	if (p_keep_state) {
+
+		print_line("RELOAD KEEP "+p_script->path);
+		for (Set<Object*>::Element *E=p_script->instances.front();E;) {
+
+			Set<Object*>::Element *N = E->next();
+
+			ScriptInstance *si = E->get()->get_script_instance();
+			if (si->is_placeholder()) {
+				PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance*>(si);
+
+				if (p_script->is_tool()) {
+					//re-create as an instance
+					p_script->placeholders.erase(psi); //remove placeholder
+
+					GDInstance* instance = memnew( GDInstance );
+					instance->base_ref=E->get()->cast_to<Reference>();
+					instance->members.resize(p_script->member_indices.size());
+					instance->script=Ref<GDScript>(p_script);
+					instance->owner=E->get();
+
+					//needed for hot reloading
+					for(Map<StringName,GDScript::MemberInfo>::Element *E=p_script->member_indices.front();E;E=E->next()) {
+						instance->member_indices_cache[E->key()]=E->get().index;
+					}
+					instance->owner->set_script_instance(instance);
+
+
+					/* STEP 2, INITIALIZE AND CONSRTUCT */
+
+					Variant::CallError ce;
+					p_script->initializer->call(instance,NULL,0,ce);
+
+					if (ce.error!=Variant::CallError::CALL_OK) {
+						//well, tough luck, not goinna do anything here
+					}
+				}
+			} else {
+				print_line("RELOAD MEMBERS");
+				GDInstance *gi = static_cast<GDInstance*>(si);
+				gi->reload_members();
+			}
+
+			E=N;
+
+		}
+
+
+	}
 #endif
 
 	p_script->valid=true;
 	return OK;
 }
 
-Error GDCompiler::compile(const GDParser *p_parser,GDScript *p_script) {
+Error GDCompiler::compile(const GDParser *p_parser,GDScript *p_script,bool p_keep_state) {
 
 	err_line=-1;
 	err_column=-1;
@@ -1772,9 +1836,7 @@ Error GDCompiler::compile(const GDParser *p_parser,GDScript *p_script) {
 
 	source=p_script->get_path();
 
-
-
-	Error err = _parse_class(p_script,NULL,static_cast<const GDParser::ClassNode*>(root));
+	Error err = _parse_class(p_script,NULL,static_cast<const GDParser::ClassNode*>(root),p_keep_state);
 
 	if (err)
 		return err;
diff --git a/modules/gdscript/gd_compiler.h b/modules/gdscript/gd_compiler.h
index 32e18c6dcf..7cf575e3d6 100644
--- a/modules/gdscript/gd_compiler.h
+++ b/modules/gdscript/gd_compiler.h
@@ -144,7 +144,7 @@ class GDCompiler {
 	int _parse_expression(CodeGen& codegen,const GDParser::Node *p_expression, int p_stack_level,bool p_root=false,bool p_initializer=false);
 	Error _parse_block(CodeGen& codegen,const GDParser::BlockNode *p_block,int p_stack_level=0,int p_break_addr=-1,int p_continue_addr=-1);
 	Error _parse_function(GDScript *p_script,const GDParser::ClassNode *p_class,const GDParser::FunctionNode *p_func,bool p_for_ready=false);
-	Error _parse_class(GDScript *p_script,GDScript *p_owner,const GDParser::ClassNode *p_class);
+	Error _parse_class(GDScript *p_script,GDScript *p_owner,const GDParser::ClassNode *p_class,bool p_keep_state);
 	int err_line;
 	int err_column;
 	StringName source;
@@ -152,7 +152,7 @@ class GDCompiler {
 
 public:
 
-	Error compile(const GDParser *p_parser,GDScript *p_script);
+	Error compile(const GDParser *p_parser, GDScript *p_script, bool p_keep_state=false);
 
 	String get_error() const;
 	int get_error_line() const;
diff --git a/modules/gdscript/gd_script.cpp b/modules/gdscript/gd_script.cpp
index 7672faf620..dcd0641f76 100644
--- a/modules/gdscript/gd_script.cpp
+++ b/modules/gdscript/gd_script.cpp
@@ -101,6 +101,12 @@ GDInstance* GDScript::_create_instance(const Variant** p_args,int p_argcount,Obj
 	instance->members.resize(member_indices.size());
 	instance->script=Ref<GDScript>(this);
 	instance->owner=p_owner;
+#ifdef DEBUG_ENABLED
+	//needed for hot reloading
+	for(Map<StringName,MemberInfo>::Element *E=member_indices.front();E;E=E->next()) {
+		instance->member_indices_cache[E->key()]=E->get().index;
+	}
+#endif
 	instance->owner->set_script_instance(instance);
 
 	/* STEP 2, INITIALIZE AND CONSRTUCT */
@@ -500,10 +506,10 @@ void GDScript::_set_subclass_path(Ref<GDScript>& p_sc,const String& p_path) {
 	}
 }
 
-Error GDScript::reload() {
+Error GDScript::reload(bool p_keep_state) {
 
 
-	ERR_FAIL_COND_V(instances.size(),ERR_ALREADY_IN_USE);
+	ERR_FAIL_COND_V(!p_keep_state && instances.size(),ERR_ALREADY_IN_USE);
 
 	String basedir=path;
 
@@ -531,7 +537,7 @@ Error GDScript::reload() {
 	bool can_run = ScriptServer::is_scripting_enabled() || parser.is_tool_script();
 
 	GDCompiler compiler;
-	err = compiler.compile(&parser,this);
+	err = compiler.compile(&parser,this,p_keep_state);
 
 	if (err) {
 
@@ -837,7 +843,7 @@ void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 }
 
 
-GDScript::GDScript() {
+GDScript::GDScript() : script_list(this) {
 
 
 	_static_ref=this;
@@ -851,12 +857,33 @@ GDScript::GDScript() {
 	source_changed_cache=false;
 #endif
 
+#ifdef DEBUG_ENABLED
+	if (GDScriptLanguage::get_singleton()->lock) {
+		GDScriptLanguage::get_singleton()->lock->lock();
+	}
+	GDScriptLanguage::get_singleton()->script_list.add(&script_list);
+
+	if (GDScriptLanguage::get_singleton()->lock) {
+		GDScriptLanguage::get_singleton()->lock->unlock();
+	}
+#endif
 }
 
 GDScript::~GDScript() {
 	for (Map<StringName,GDFunction*>::Element *E=member_functions.front();E;E=E->next()) {
 		memdelete( E->get() );
 	}
+
+#ifdef DEBUG_ENABLED
+	if (GDScriptLanguage::get_singleton()->lock) {
+		GDScriptLanguage::get_singleton()->lock->lock();
+	}
+	GDScriptLanguage::get_singleton()->script_list.remove(&script_list);
+
+	if (GDScriptLanguage::get_singleton()->lock) {
+		GDScriptLanguage::get_singleton()->lock->unlock();
+	}
+#endif
 }
 
 
@@ -1218,6 +1245,37 @@ ScriptLanguage *GDInstance::get_language() {
 	return GDScriptLanguage::get_singleton();
 }
 
+void GDInstance::reload_members() {
+
+#ifdef DEBUG_ENABLED
+
+	members.resize(script->member_indices.size()); //resize
+
+	Vector<Variant> new_members;
+	new_members.resize(script->member_indices.size());
+
+	//pass the values to the new indices
+	for(Map<StringName,GDScript::MemberInfo>::Element *E=script->member_indices.front();E;E=E->next()) {
+
+		if (member_indices_cache.has(E->key())) {
+			Variant value = members[member_indices_cache[E->key()]];
+			new_members[E->get().index]=value;
+		}
+
+	}
+
+	//apply
+	members=new_members;
+
+	//pass the values to the new indices
+	member_indices_cache.clear();
+	for(Map<StringName,GDScript::MemberInfo>::Element *E=script->member_indices.front();E;E=E->next()) {
+
+		member_indices_cache[E->key()]=E->get().index;
+	}
+
+#endif
+}
 
 GDInstance::GDInstance() {
 	owner=NULL;
@@ -1441,6 +1499,65 @@ int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr,int p_i
 }
 
 
+struct GDScriptDepSort {
+
+	//must support sorting so inheritance works properly (parent must be reloaded first)
+	bool operator()(const Ref<GDScript> &A, const Ref<GDScript>& B) const {
+
+		if (A==B)
+			return false; //shouldn't happen but..
+		const GDScript *I=B->get_base().ptr();
+		while(I) {
+			if (I==A.ptr()) {
+				// A is a base of B
+				return true;
+			}
+
+			I=I->get_base().ptr();
+		}
+
+		return false; //not a base
+	}
+};
+
+void GDScriptLanguage::reload_all_scripts() {
+
+
+
+#ifdef DEBUG_ENABLED
+	print_line("RELOAD ALL SCRIPTS");
+	if (lock) {
+		lock->lock();
+	}
+
+	List<Ref<GDScript> > scripts;
+
+	SelfList<GDScript> *elem=script_list.first();
+	while(elem) {
+		if (elem->self()->get_path().is_resource_file()) {
+			print_line("FOUND: "+elem->self()->get_path());
+			scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
+		}
+		elem=elem->next();
+	}
+
+	if (lock) {
+		lock->unlock();
+	}
+
+	//as scripts are going to be reloaded, must proceed without locking here
+
+	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
+
+	for(List<Ref<GDScript> >::Element *E=scripts.front();E;E=E->next()) {
+
+		print_line("RELOADING: "+E->get()->get_path());
+		E->get()->load_source_code(E->get()->get_path());
+		E->get()->reload(true);
+	}
+#endif
+}
+
 void GDScriptLanguage::frame() {
 
 	//	print_line("calls: "+itos(calls));
diff --git a/modules/gdscript/gd_script.h b/modules/gdscript/gd_script.h
index 05e1646408..f052d13685 100644
--- a/modules/gdscript/gd_script.h
+++ b/modules/gdscript/gd_script.h
@@ -107,6 +107,7 @@ friend class GDScriptLanguage;
 	String source;
 	String path;
 	String name;
+	SelfList<GDScript> script_list;
 
 
 	GDInstance* _create_instance(const Variant** p_args,int p_argcount,Object *p_owner,bool p_isref,Variant::CallError &r_error);
@@ -165,7 +166,7 @@ public:
 	virtual void set_source_code(const String& p_code);
 	virtual void update_exports();
 
-	virtual Error reload();
+	virtual Error reload(bool p_keep_state=false);
 
 	virtual String get_node_type() const;
 	void set_script_path(const String& p_path) { path=p_path; } //because subclasses need a path too...
@@ -186,9 +187,13 @@ class GDInstance : public ScriptInstance {
 friend class GDScript;
 friend class GDFunction;
 friend class GDFunctions;
+friend class GDCompiler;
 
 	Object *owner;
 	Ref<GDScript> script;
+#ifdef DEBUG_ENABLED
+	Map<StringName,int> member_indices_cache; //used only for hot script reloading
+#endif
 	Vector<Variant> members;
 	bool base_ref;
 
@@ -209,7 +214,7 @@ public:
 	virtual void call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount);
 	virtual void call_multilevel_reversed(const StringName& p_method,const Variant** p_args,int p_argcount);
 
-    Variant debug_get_member_by_index(int p_idx) const { return members[p_idx]; }
+	Variant debug_get_member_by_index(int p_idx) const { return members[p_idx]; }
 
 	virtual void notification(int p_notification);
 
@@ -219,6 +224,7 @@ public:
 
 	void set_path(const String& p_path);
 
+	void reload_members();
 
 	GDInstance();
 	~GDInstance();
@@ -256,6 +262,10 @@ class GDScriptLanguage : public ScriptLanguage {
 
 
 	Mutex *lock;
+
+friend class GDScript;
+
+	SelfList<GDScript>::List script_list;
 friend class GDFunction;
 
 	SelfList<GDFunction>::List function_list;
@@ -378,6 +388,8 @@ public:
 	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems=-1,int p_max_depth=-1);
 	virtual String debug_parse_stack_level_expression(int p_level,const String& p_expression,int p_max_subitems=-1,int p_max_depth=-1);
 
+	virtual void reload_all_scripts();
+
 	virtual void frame();
 
 	virtual void get_public_functions(List<MethodInfo> *p_functions) const;