Rewrite in Rust

[LeviSnoot]

Writing this project in Python was great for proof-of-concept, but the code and language is very inefficient at this stage, so I'm taking up the task of rewriting it in Rust. This will take some time to do, as I am not experienced with it yet, but this will certainly improve performance drastically.

Especially when I eventually get to implementing #6. It has always been a goal to have this be runnable as a background service, so the user doesn't manually have to run it every time they start Fortnite.

This should also make the idea of creating a GUI wrapper around this project more feasible.

[LeviSnoot]

I have created an initial commit for those curious. Before I proceed with further rewriting of playerStatus.py, I'm going to look into a less invasive check for whether the Fortnite process is running by using the Windows API instead of looping for the process which was a pretty bad idea.

[LeviSnoot]

Windows API was a bit too deep of a rabbit hole to dive into, at least for now. I've decided to increase the modularity of the code by splitting the functions of the player status script into multiple scripts that the main script can utilize when needed. So far the basic functionality is starting to come along, but we're still a long ways off.

That said I am getting more and more excited about this rewrite the more I progress on it. It feels like we're gaining a lot of much needed improvements naturally in this process. Plus, building is a lot more straightforward in Rust, so once this is ready for release, we should be able to start making proper releases and updates, so people won't need to worry about installing dependencies if they just wanna get up and running.

[LeviSnoot]

Implemented Intensity and album art url construction just now. It's getting a bit hard to keep track of what to do next, so I took some time to write up a proper game plan. Posting it here for transparency

---

Let's compare the contents of the playerStatus.py with the current Rust code to identify what still needs to be ported. Let's also ensure that we maintain a modular and asynchronous code structure by organizing functions into different files that can call on each other as needed.

---

playerStatus.py Overview

playerStatus.py performs the following tasks:

1. Initialization:

• Defines the initial status.json structure (initial_status).
• Checks if status.json exists; if not, creates it with initial values.

2. Status File Handling Functions:

• write_status_to_file(status): Writes the status to status.json.
• read_status_from_file(): Reads the status from status.json.

3. State Management Functions:

• reset_state(): Resets global state variables and updates status.json.
• update_state(new_state): Updates in_backstage state and writes to status.json.
• update_song_state(...): Updates song-related status fields and writes to status.json.
• update_playback_start_time(playback_start_time): Updates playback start time in status.json.
• end_song_state(): Marks the end of a song, increments round_counter, and updates status.json.

4. Utility Functions:

• is_game_running(): Checks if the Fortnite game is running.
• get_song_info(song_id): Fetches song info from the API.
• format_instrument_name(instrument): Formats the instrument name.
• format_difficulty_name(difficulty): Formats the difficulty name.

5. Main Monitoring Loop (monitor_log_file()):

• Monitors the Fortnite log file in real-time.
• Detects various events based on log lines and updates states accordingly.
• Manages global state variables to keep track of the game's status.

---

Rust Code Overview

The Rust code is organized into multiple modules:

1. main.rs:

• Initializes the status file.
• Starts monitoring the log file (monitor_log_file()).
• Contains an example of fetching song info.

2. status.rs:

• Defines the Status struct.
• Provides functions to initialize, read, and write the status file.

3. fetch.rs:

• Contains the fetch_song_info function to get song information from the API.

4. monitor.rs:

• Watches the Fortnite log file for changes.
• Processes new log lines to detect events and updates the status accordingly.
• Contains helper functions extract_song_id, extract_instrument_and_difficulty, and format_instrument_name.

---

Missing Components

Based on the comparison, here's what remains to be ported from the playerStatus.py to the Rust code:

1. Game Process Detection

• Python: Uses psutil to check if the Fortnite process is running (is_game_running()).
• Rust: Not implemented yet.

Action: Implement a function to check if the Fortnite game is running. You can use the sysinfo crate for Rust to achieve this.

2. State Management Functions

• reset_state():
  • Python: Resets global state variables and updates status.json.
  • Rust: Not implemented yet.
• update_state(new_state):
  • Python: Updates in_backstage state and writes to status.json.
  • Rust: Handled when processing log lines related to is_backstage in status.json. in_backstage was renamed to is_backstage in the Rust code.
• update_song_state(...):
  • Python: Updates song-related status fields and writes to status.json.
  • Rust: Updates some song-related fields but may not fully match the Python logic.
• update_playback_start_time(playback_start_time):
  • Python: Updates playback_start_time in status.json.
  • Rust: Not implemented yet.
• end_song_state():
  • Python: Marks the end of a song, increments round_counter, and updates status.json.
  • Rust: Partially implemented when a song ends but may not handle round_number.

Action: Implement these state management functions in Rust, ensuring they update the Status struct and write to status.json.

3. Utility Functions

• format_difficulty_name(difficulty):
  • Python: Formats the difficulty level.
  • Rust: Not implemented yet.
• is_game_running():
  • Python: Checks if the game process is running.
  • Rust: Not implemented yet.

Action: Implement format_difficulty_name and is_game_running in Rust.

4. Handling Additional Log Events

The Python script handles various log events that are not yet implemented in Rust:

• Battle Stage Mode Detection:
  • Python: Updates is_battle_stage.
  • Rust: Not implemented yet (this should be changed to game_mode which would pass either main_stage or battle_stage).
• Player Loading into a Game:
  • Python: Detects when the player is loading into a game.
  • Rust: Not implemented yet.
• Return to Main Menu:
  • Python: Resets state and handles in_lobby state.
  • Rust: Not implemented yet.
• Playback Start Time Detection:
  • Python: Uses regex to detect playback start and updates playback_start_time.
  • Rust: Not implemented yet.
• Matchmaking Started/Canceled Handling:
  • Python: Updates matchmaking_started and prints messages.
  • Rust: Partially implemented.
• Sleep Mode Handling:
  • Python: Updates in_sleep_mode state.
  • Rust: Handles entering and leaving sleep mode but may not update in_sleep_mode state variable (reconsider implementing this in the Rust code).

Action: Incorporate these log event handlers into the Rust code, updating the status and state variables accordingly.

5. Global State Variables

The Python script uses several global state variables to manage the game state:

• in_backstage
• matchmaking_started
• playing_song
• current_song
• current_artist
• current_album_art
• current_instrument
• current_intensity
• current_difficulty
• is_battle_stage
• in_lobby
• in_sleep_mode
• game_running_state
• in_song_results
• round_counter

Action: Introduce equivalent state variables in Rust to track the game state across log lines. This may involve creating a struct to hold the state variables and passing it around as needed.

6. Exception Handling and Graceful Shutdown

• Python: Handles KeyboardInterrupt to reset state and exit gracefully.
• Rust: Not implemented yet (this may not be necessary if the Rust code is designed to handle unexpected events gracefully).

Action: Implement graceful shutdown in Rust, possibly using the ctrlc crate to capture Ctrl+C interrupts and reset the state before exiting.

---

Game Plan

Based on the identified missing components, here's a step-by-step plan to complete the porting process:

Step 1: Implement Game Process Detection

• Create a new module process_check.rs:
  • Use the sysinfo crate to check if the Fortnite process (FortniteClient-Win64-Shipping.exe) is running.
  • Implement an is_game_running() function.
• Integrate with monitor_log_file():
  • Modify main.rs to loop and only call monitor_log_file() when the game is running.
  • Adjust monitor_log_file() to handle the game starting and stopping.

Step 2: Implement State Management Functions

• In status.rs:
  • Add functions reset_state(), update_state(new_state), update_song_state(...), and end_song_state().
  • These functions will update the Status struct and write to status.json.
• In monitor.rs:
  • Modify process_log_line() to call these functions at the appropriate times.
  • Ensure that round_number is incremented when a song ends.

Step 3: Implement Utility Functions

• Format Difficulty Names:
  • Add format_difficulty_name(difficulty) function in monitor.rs or a new utils.rs module.
  • Map raw difficulty names to user-friendly names similar to the Python script.
• Update extract_instrument_and_difficulty():
  • Modify this function to use format_instrument_name and format_difficulty_name.

Step 4: Handle Additional Log Events

• Battle Stage Mode Detection:
  • Detect log lines indicating entering or leaving Battle Stage mode.
  • Update status.is_battle_stage accordingly (again, we'll want to change this to game_mode which would pass either main_stage or battle_stage).
• Player Loading into a Game:
  • Detect log lines indicating loading into a game.
  • Optionally update the status or print messages.
• Return to Main Menu Handling:
  • Detect log lines indicating returning to the main menu.
  • Call reset_state() and handle the in_lobby state.
• Playback Start Time Detection:
  • Use regex to detect playback start lines.
  • Update status.playback_start_time.
• Sleep Mode Handling:
  • Update in_sleep_mode state when entering or leaving sleep mode (we're not really making use of this in the python script, so we should reconsider implementing it in the Rust code).
  • Update status.json if needed.

Step 5: Introduce State Variables

• Create a GameState Struct:
  • Define a struct to hold state variables like is_backstage, playing_song, current_song, etc.
  • Pass this struct to functions that need to modify or access the state.
• In monitor.rs:
  • Initialize the GameState struct.
  • Update the state variables as log lines are processed.

Step 6: Implement Graceful Shutdown

• Use the ctrlc Crate:
  • Add the ctrlc crate to capture Ctrl+C interrupts.
  • Implement a handler to call reset_state() and exit gracefully.

Step 7: Modularize the Code Further

• Organize Modules:
  • Keep related functions together in modules.
    • For example, move utility functions to utils.rs.
    • Move state management functions to state.rs.
• Ensure Asynchronous Operations are Handled Properly:
  • Since file I/O and API calls are asynchronous, ensure that all async functions are properly awaited.

Step 8: Testing and Debugging

• Add Logging and Error Handling:
  • Use logging to trace execution and assist with debugging.
  • Handle errors gracefully, providing meaningful messages.
• Test Each Component Individually:
  • Verify that each new function works as expected.
  • Ensure that the overall application behaves correctly.

Step 9: Upgrade dependencies

• Check Cargo.toml:
  • Upgrade dependencies to the latest versions.
  • Check for any breaking changes.

---

Next Steps

• Implement each component step by step, testing as we go.
• Refactor and organize code into modules (process_check.rs, state.rs, utils.rs, etc.).
• Ensure asynchronous operations are properly handled with async/await.
• Add appropriate error handling and logging for better debugging and maintenance.
• Implement web server for the Stream Widget and Discord RPC using the discord-rich-presence crate.