4 files changed, 63 insertions, 15 deletions

diff --git a/core/io/file_access_compressed.cpp b/core/io/file_access_compressed.cpp
index 6c4310a572..102cd9cf6c 100644
--- a/core/io/file_access_compressed.cpp
+++ b/core/io/file_access_compressed.cpp
@@ -208,7 +208,8 @@ void FileAccessCompressed::seek(size_t p_position) {
 		if (p_position == read_total) {
 			at_end = true;
 		} else {
-
+			at_end = false;
+			read_eof = false;
 			int block_idx = p_position / block_size;
 			if (block_idx != read_block) {
 
diff --git a/core/math/math_funcs.h b/core/math/math_funcs.h
index a712356ddc..af845ca01e 100644
--- a/core/math/math_funcs.h
+++ b/core/math/math_funcs.h
@@ -255,16 +255,16 @@ public:
 	static _ALWAYS_INLINE_ float round(float p_val) { return (p_val >= 0) ? Math::floor(p_val + 0.5) : -Math::floor(-p_val + 0.5); }
 
 	static _ALWAYS_INLINE_ int64_t wrapi(int64_t value, int64_t min, int64_t max) {
-		int64_t rng = max - min;
-		return (rng != 0) ? min + ((((value - min) % rng) + rng) % rng) : min;
+		int64_t range = max - min;
+		return range == 0 ? min : min + ((((value - min) % range) + range) % range);
 	}
 	static _ALWAYS_INLINE_ double wrapf(double value, double min, double max) {
-		double rng = max - min;
-		return (!is_equal_approx(rng, 0.0)) ? value - (rng * Math::floor((value - min) / rng)) : min;
+		double range = max - min;
+		return is_zero_approx(range) ? min : value - (range * Math::floor((value - min) / range));
 	}
 	static _ALWAYS_INLINE_ float wrapf(float value, float min, float max) {
-		float rng = max - min;
-		return (!is_equal_approx(rng, 0.0f)) ? value - (rng * Math::floor((value - min) / rng)) : min;
+		float range = max - min;
+		return is_zero_approx(range) ? min : value - (range * Math::floor((value - min) / range));
 	}
 
 	// double only, as these functions are mainly used by the editor and not performance-critical,
diff --git a/core/script_debugger_remote.cpp b/core/script_debugger_remote.cpp
index e7ff7a3aef..5f01e043c4 100644
--- a/core/script_debugger_remote.cpp
+++ b/core/script_debugger_remote.cpp
@@ -357,10 +357,11 @@ void ScriptDebuggerRemote::_get_output() {
 		locking = false;
 	}
 
-	if (n_errors_dropped > 0) {
+	if (n_errors_dropped == 1) {
+		// Only print one message about dropping per second
 		OutputError oe;
 		oe.error = "TOO_MANY_ERRORS";
-		oe.error_descr = "Too many errors! " + String::num_int64(n_errors_dropped) + " errors were dropped.";
+		oe.error_descr = "Too many errors! Ignoring errors for up to 1 second.";
 		oe.warning = false;
 		uint64_t time = OS::get_singleton()->get_ticks_msec();
 		oe.hr = time / 3600000;
@@ -368,7 +369,20 @@ void ScriptDebuggerRemote::_get_output() {
 		oe.sec = (time / 1000) % 60;
 		oe.msec = time % 1000;
 		errors.push_back(oe);
-		n_errors_dropped = 0;
+	}
+
+	if (n_warnings_dropped == 1) {
+		// Only print one message about dropping per second
+		OutputError oe;
+		oe.error = "TOO_MANY_WARNINGS";
+		oe.error_descr = "Too many warnings! Ignoring warnings for up to 1 second.";
+		oe.warning = true;
+		uint64_t time = OS::get_singleton()->get_ticks_msec();
+		oe.hr = time / 3600000;
+		oe.min = (time / 60000) % 60;
+		oe.sec = (time / 1000) % 60;
+		oe.msec = time % 1000;
+		errors.push_back(oe);
 	}
 
 	while (errors.size()) {
@@ -934,6 +948,19 @@ void ScriptDebuggerRemote::send_error(const String &p_func, const String &p_file
 	oe.msec = time % 1000;
 	Array cstack;
 
+	uint64_t ticks = OS::get_singleton()->get_ticks_usec() / 1000;
+	msec_count += ticks - last_msec;
+	last_msec = ticks;
+
+	if (msec_count > 1000) {
+		msec_count = 0;
+
+		err_count = 0;
+		n_errors_dropped = 0;
+		warn_count = 0;
+		n_warnings_dropped = 0;
+	}
+
 	cstack.resize(p_stack_info.size() * 3);
 	for (int i = 0; i < p_stack_info.size(); i++) {
 		cstack[i * 3 + 0] = p_stack_info[i].file;
@@ -942,15 +969,28 @@ void ScriptDebuggerRemote::send_error(const String &p_func, const String &p_file
 	}
 
 	oe.callstack = cstack;
+	if (oe.warning) {
+		warn_count++;
+	} else {
+		err_count++;
+	}
 
 	mutex->lock();
 
 	if (!locking && tcp_client->is_connected_to_host()) {
 
-		if (errors.size() >= max_errors_per_frame) {
-			n_errors_dropped++;
+		if (oe.warning) {
+			if (warn_count > max_warnings_per_second) {
+				n_warnings_dropped++;
+			} else {
+				errors.push_back(oe);
+			}
 		} else {
-			errors.push_back(oe);
+			if (err_count > max_errors_per_second) {
+				n_errors_dropped++;
+			} else {
+				errors.push_back(oe);
+			}
 		}
 	}
 
@@ -1070,10 +1110,13 @@ ScriptDebuggerRemote::ScriptDebuggerRemote() :
 		mutex(Mutex::create()),
 		max_messages_per_frame(GLOBAL_GET("network/limits/debugger_stdout/max_messages_per_frame")),
 		n_messages_dropped(0),
-		max_errors_per_frame(GLOBAL_GET("network/limits/debugger_stdout/max_errors_per_frame")),
+		max_errors_per_second(GLOBAL_GET("network/limits/debugger_stdout/max_errors_per_second")),
+		max_warnings_per_second(GLOBAL_GET("network/limits/debugger_stdout/max_warnings_per_second")),
 		n_errors_dropped(0),
 		max_cps(GLOBAL_GET("network/limits/debugger_stdout/max_chars_per_second")),
 		char_count(0),
+		err_count(0),
+		warn_count(0),
 		last_msec(0),
 		msec_count(0),
 		locking(false),
diff --git a/core/script_debugger_remote.h b/core/script_debugger_remote.h
index 1fc9d7c7f1..a5bfd7a32d 100644
--- a/core/script_debugger_remote.h
+++ b/core/script_debugger_remote.h
@@ -91,11 +91,15 @@ class ScriptDebuggerRemote : public ScriptDebugger {
 	int max_messages_per_frame;
 	int n_messages_dropped;
 	List<OutputError> errors;
-	int max_errors_per_frame;
+	int max_errors_per_second;
+	int max_warnings_per_second;
 	int n_errors_dropped;
+	int n_warnings_dropped;
 
 	int max_cps;
 	int char_count;
+	int err_count;
+	int warn_count;
 	uint64_t last_msec;
 	uint64_t msec_count;