Merge pull request #81 from fs-c/perf-testing-1

Fix randomization/humanization bugs and minor improvements

Author: fs-c

README.md

@@ -36,6 +36,10 @@ _The following is only relevant to developers looking to build the project from
 # Get the code
 git clone https://github.com/fs-c/maniac.git
 
+# Get submodule dependencies
+git submodule init
+git submodule update
+
 # Building out-of-source is preferred
 mkdir build
 cd build
@@ -68,7 +72,8 @@ Of course please also feel free to open an issue for any questions you may have.
 
 ## Thanks
 
-- n0b453c0d3r on UC and [mrflashstudio](https://github.com/mrflashstudio) for
-  providing up to date signatures and offsets
-- [ocornut](https://github.com/ocornut) for the [imgui](https://github.com/ocornut/imgui) library
+- n0b453c0d3r on UC, [mrflashstudio](https://github.com/mrflashstudio) and [daycheat](https://github.com/daycheat) for
+  providing up-to-date signatures and offsets and helpful discussion
+- LSNM for particularly helpful suggestions and bug reports
+- [ocornut](https://github.com/ocornut) for the [imgui](https://github.com/ocornut/imgui) library 
 - to everyone who reported bugs and provided feedback

app/app.cpp

@@ -33,6 +33,8 @@ static void set_priority_class(int priority) {
 int main(int, char **) {
     std::string message;
 
+    maniac::config.read_from_file();
+
     auto run = [&message](osu::Osu &osu) {
         maniac::osu = &osu;
 
@@ -42,32 +44,32 @@ int main(int, char **) {
 
         message = "found beatmap";
 
-        std::vector<osu::Action> actions;
+        std::vector<osu::HitObject> hit_objects;
 
         for (int i = 0; i < 10; i++) {
             try {
-                actions = maniac::get_actions(osu.get_game_time());
+                hit_objects = osu.get_hit_objects();
 
                 break;
             } catch (std::exception &err) {
-                debug("get actions attempt %d failed: %s", i + 1, err.what());
+                debug("get hit objects attempt %d failed: %s", i + 1, err.what());
 
                 std::this_thread::sleep_for(std::chrono::milliseconds(200));
             }
         }
 
-        if (actions.empty()) {
-            throw std::runtime_error("failed getting actions");
+        if (hit_objects.empty()) {
+            throw std::runtime_error("failed getting hit objects");
         }
 
         set_priority_class(HIGH_PRIORITY_CLASS);
 
-        maniac::randomize(actions, maniac::config.randomization_range);
-        maniac::humanize(actions, maniac::config.humanization_modifier);
+        maniac::randomize(hit_objects, maniac::config.randomization_range);
+        maniac::humanize(hit_objects, maniac::config.humanization_modifier);
 
         message = "playing";
 
-        maniac::play(actions);
+        maniac::play(maniac::to_actions(hit_objects, osu.get_game_time()));
 
         set_priority_class(NORMAL_PRIORITY_CLASS);
     };
@@ -123,6 +125,8 @@ int main(int, char **) {
         ImGui::End();
     });
 
+    maniac::config.write_to_file();
+
     thread.request_stop();
 
     return EXIT_SUCCESS;

lib/humanization.cpp

@@ -1,75 +1,61 @@
 #include <maniac/common.h>
 #include <maniac/maniac.h>
 
-void maniac::randomize(std::vector<osu::Action> &actions, std::pair<int, int> range) {
+void maniac::randomize(std::vector<osu::HitObject> &hit_objects, std::pair<int, int> range) {
 	if (!range.first && !range.second)
 		return;
 
 	std::random_device rd;
 	std::mt19937 gen(rd());
+
 	std::uniform_int_distribution<> distr(range.first, range.second);
 
-	for (auto &action : actions) {
-		action.time += distr(gen);
+	for (auto &hit_object : hit_objects) {
+        // if it's a slider we want to randomize start and end, if it's not we ignore end anyway
+        hit_object.start_time += distr(gen);
+        hit_object.end_time += distr(gen);
 	}
 
-	debug("randomized %d actions with a range of [%d, %d]", actions.size(), range.first,
+	debug("randomized %d hit objects with a range of [%d, %d]", hit_objects.size(), range.first,
 		range.second);
 }
 
-static std::vector<int> actions_per_frame(const std::vector<osu::Action> &actions,
-	int time_frame = 1000) {
-	std::vector<int> frames = {};
-	const size_t chunks_needed = (actions.back().time / time_frame) + 1;
-
-	debug("will need %d frames", chunks_needed);
-
-	for (size_t chunk_i = 0; chunk_i < chunks_needed; chunk_i++) {
-		frames.emplace_back(0);
-
-		for (const auto &action : actions) {
-			const int32_t lower_bound = time_frame * chunk_i;
-			const int32_t upper_bound = lower_bound + time_frame;
-
-			if (action.time >= lower_bound && action.time <= upper_bound) {
-				frames[chunk_i]++;
-			}
-		}
-	}
-
-	return frames;
-}
-
-void maniac::humanize(std::vector<osu::Action> &actions, int modifier) {
-	if (!modifier)
-		return;
+void maniac::humanize(std::vector<osu::HitObject> &hit_objects, int modifier) {
+	if (!modifier) {
+        return;
+    }
 
 	const auto actual_modifier = static_cast<double>(modifier) / 100.0;
 
-	constexpr auto frame_range = 1000;
-	const auto frames = actions_per_frame(actions, frame_range);
+    // count number of hits/unit of time (slice size)
+	constexpr auto slice_size = 1000;
 
-	std::random_device rd;
-	std::mt19937 gen(rd());
+    const auto latest_hit = std::max_element(hit_objects.begin(), hit_objects.end(), [](auto a, auto b) {
+        return a.end_time < b.end_time;
+    })->end_time;
 
-	std::uniform_int_distribution<> offset_distr(-5, 5);
+    auto slices = std::vector<int>{};
+    slices.resize((latest_hit / slice_size) + 1);
 
-	const auto frames_size = frames.size();
-	for (auto &action : actions) {
-		const auto random_offset = offset_distr(gen);
-		const size_t frame_i = action.time / frame_range;
+    for (const auto &hit_object : hit_objects) {
+        slices.at(hit_object.start_time / slice_size)++;
 
-		if (frame_i >= frames_size) {
-			debug("ignoring invalid frame_i (%d)", frame_i);
+        if (hit_object.is_slider) {
+            slices.at(hit_object.end_time / slice_size)++;
+        }
+    }
 
-			continue;
-		}
+    for (auto &hit_object : hit_objects) {
+        const auto start_offset = static_cast<int>(slices.at(hit_object.start_time / slice_size) * actual_modifier);
 
-		const int offset = static_cast<int>(frames.at(frame_i) * actual_modifier) + random_offset;
+        hit_object.start_time += start_offset;
 
-		action.time += offset;
-	}
+        if (hit_object.is_slider) {
+            const auto end_offset = static_cast<int>(slices.at(hit_object.end_time / slice_size) * actual_modifier);
+
+            hit_object.end_time += end_offset;
+        }
+    }
 
-	debug("%s %d %s %d %s %dms %s %f", "humanized", actions.size(), "actions over",
-		frames_size, "time frames of", frame_range, "with a modifier of", actual_modifier);
+	debug("humanized %d hit objects (%d slices of %dms) with modifier %d", hit_objects.size(), slices.size(), slice_size, modifier);
 }

lib/include/maniac/maniac.h

@@ -4,26 +4,97 @@
 #include <utility>
 #include <maniac/osu.h>
 #include <maniac/common.h>
+#include <fstream>
 
 namespace maniac {
 	struct config {
         int tap_time = 20;
 		bool mirror_mod = false;
-		int compensation_offset = 0;
+		int compensation_offset = -15;
 		int humanization_modifier = 0;
 		std::pair<int, int> randomization_range = { 0, 0 };
+
+        // TODO: This isn't configurable yet, use a non-shit config format
+        std::string keys = "asdfjkl;";
+
+        // TODO: Would be good to have the read/write stuff be in a constructor/destructor
+
+        void read_from_file() {
+            std::fstream file{"maniac-config", std::fstream::binary | std::fstream::in};
+
+            if (!file.is_open()) {
+                debug("couldn't open config file for reading");
+
+                return;
+            }
+
+            file.read(reinterpret_cast<char *>(&tap_time), sizeof tap_time);
+            file.read(reinterpret_cast<char *>(&mirror_mod), sizeof mirror_mod);
+            file.read(reinterpret_cast<char *>(&compensation_offset), sizeof compensation_offset);
+            file.read(reinterpret_cast<char *>(&humanization_modifier), sizeof humanization_modifier);
+            file.read(reinterpret_cast<char *>(&randomization_range.first), sizeof randomization_range.first);
+            file.read(reinterpret_cast<char *>(&randomization_range.second), sizeof randomization_range.second);
+
+            debug("loaded config from file (%s)", keys.c_str());
+        }
+
+        void write_to_file() {
+            std::fstream file{"maniac-config", std::fstream::binary | std::fstream::trunc | std::fstream::out};
+
+            if (!file.is_open()) {
+                debug("couldn't open config file for writing");
+
+                return;
+            }
+
+            file.write(reinterpret_cast<char *>(&tap_time), sizeof tap_time);
+            file.write(reinterpret_cast<char *>(&mirror_mod), sizeof mirror_mod);
+            file.write(reinterpret_cast<char *>(&compensation_offset), sizeof compensation_offset);
+            file.write(reinterpret_cast<char *>(&humanization_modifier), sizeof humanization_modifier);
+            file.write(reinterpret_cast<char *>(&randomization_range.first), sizeof randomization_range.first);
+            file.write(reinterpret_cast<char *>(&randomization_range.second), sizeof randomization_range.second);
+
+            debug("wrote config to file");
+        }
 	};
 
+    struct Action {
+        char key;
+        bool down;
+        int32_t time;
+
+        short scan_code;
+
+        Action(char key, bool down, int32_t time) : key(key), down(down), time(time) {
+            static auto layout = GetKeyboardLayout(0);
+
+            scan_code = VkKeyScanEx(key, layout) & 0xFF;
+        };
+
+        bool operator < (const Action &action) const {
+            return time < action.time;
+        };
+
+        bool operator == (const Action &action) const {
+            return action.key == key && action.down == down
+                   && action.time == time;
+        };
+
+        inline void execute() const {
+            Process::send_scan_code(scan_code, down);
+        }
+    };
+
 	inline config config;
 
 	inline osu::Osu *osu;
 
-	void play(std::vector<osu::Action> &actions);
+	void play(const std::vector<Action> &&actions);
 
 	void block_until_playing();
 
-	void humanize(std::vector<osu::Action> &actions, int modifier);
-	void randomize(std::vector<osu::Action> &actions, std::pair<int, int> range);
+	void humanize(std::vector<osu::HitObject> &hit_objects, int modifier);
+	void randomize(std::vector<osu::HitObject> &hit_objects, std::pair<int, int> range);
 
-	std::vector<osu::Action> get_actions(int32_t min_time);
+	std::vector<Action> to_actions(std::vector<osu::HitObject> &hit_objects, int32_t min_time);
 }

lib/include/maniac/osu.h

@@ -14,35 +14,7 @@ namespace osu {
 		#include <maniac/osu/internal.h>
 	};
 
-    struct Action {
-		char key;
-		bool down;
-		int32_t time;
-
-        short scan_code;
-
-        Action(char key, bool down, int32_t time) : key(key), down(down), time(time) {
-            static auto layout = GetKeyboardLayout(0);
-
-            scan_code = VkKeyScanEx(key, layout) & 0xFF;
-        };
-
-		bool operator < (const Action &action) const {
-			return time < action.time;
-		};
-
-		bool operator == (const Action &action) const {
-			return action.key == key && action.down == down
-				&& action.time == time;
-		};
-
-		// Only used for debugging
-		void log() const;
-
-		inline void execute() const {
-			Process::send_scan_code(scan_code, down);
-		}
-	};
+    using HitObject = internal::hit_object;
 
 	class Osu : public Process {
 		// TODO: Generic pointers are bad in the long run.
@@ -58,9 +30,9 @@ namespace osu {
 
 		bool is_playing();
 
-		internal::map_player get_map_player();
+		std::vector<HitObject> get_hit_objects();
 
-		static std::string get_key_subset(int column_count);
+        static std::string get_key_subset(const std::string &keys, int column_count);
 	};
 
 	inline int32_t Osu::get_game_time() {

lib/include/maniac/osu/internal.h

@@ -2,14 +2,17 @@
 
 inline Process *process;
 
-struct hit_object {
+class hit_object {
 	uintptr_t base;
 
+public:
 	int32_t start_time;
 	int32_t end_time;
 	int32_t type;
 	int32_t column;
 
+    bool is_slider;
+
 	hit_object() : base(0), start_time(0), end_time(0), type(0),
 		column(0) {}
 
@@ -18,8 +21,11 @@ struct hit_object {
 		end_time = get_end_time();
 		type = get_type();
 		column = get_column();
+
+        is_slider = start_time != end_time;
 	}
 
+private:
 	[[nodiscard]] int32_t get_start_time() const {
 		return process->read_memory<int32_t>(base + 0x10);
 	}