textfiles.rs

/*
Made by: Mathew Dusome
Sept 10 2026

    In your utils.rs file add the following to the end of the file
        pub mod textfiles;
        
    Add with the other use statements
        use crate::utils::textfiles::TextFile;

 

Simple examples:

1. Save different data to separate files:

    // Save string data (player names)
    let names = vec!["Alice", "Bob", "Charlie"];
    let result = TextFile::save_strings("player_names.txt", names).await;
    if let Err(e) = result {
        println!("Error saving names: {}", e);
    }
    
    // Save integer data (scores)
    let scores = vec![100, 85, 92];
    let result = TextFile::save_numbers("high_scores.txt", scores).await;
    if let Err(e) = result {
        println!("Error saving scores: {}", e);
    }
    

2. Load different data from separate files:

    // Load player names
    let result = TextFile::load_strings("player_names.txt").await;
    Without error checking:
    let names: Vec<String> = result.unwrap_or_default();

    With error checking:
    if let Ok(names) = result {
        for name in names {
            println!("Player: {}", name);
        }
    } else if let Err(e) = result {
        println!("Error loading names: {}", e);
    }
    
    // Load high scores
    let result = TextFile::load_numbers::<i32>("high_scores.txt").await;
    if let Ok(scores) = result {
        for score in scores {
            println!("Score: {}", score);
        }
    } else if let Err(e) = result {
        println!("Error loading scores: {}", e);
    }
    

3. Load game configuration from an asset file:

    let result = TextFile::load_asset("assets/config.txt").await;
    if let Ok(content) = result {
        for line in content.lines() {
            println!("Config: {}", line);
        }
    } else if let Err(e) = result {
        println!("Error loading config: {}", e);
    }

Platform notes:
- On desktop: Saves files with the exact filename you provide (include .txt extension)
- On web: Uses browser's localStorage
- Asset loading works on both platforms, but web requires files in the assets directory
*/

use macroquad::prelude::*;

// Only use extern "C" for localStorage in WASM
#[cfg(target_arch = "wasm32")]
extern "C" {
    // Save a string to localStorage: js_local_storage_set(key_ptr, key_len, value_ptr, value_len)
    fn js_local_storage_set(key_ptr: *const u8, key_len: usize, value_ptr: *const u8, value_len: usize);
    // Get a string from localStorage: returns length, fills buffer with value if found
    // Returns length of value, or 0 if not found
    fn js_local_storage_get(key_ptr: *const u8, key_len: usize, out_ptr: *mut u8, out_len: usize) -> usize;
}

/// TextFile is a utility module for reading and writing text files
/// that works across all platforms, including web.
pub struct TextFile;

impl TextFile {
    /// Saves a vector of strings to a file or local storage (for web)
    pub async fn save(name: &str, data: Vec<String>) -> Result<(), String> {
        let joined = data.join("\n");
        
        #[cfg(target_arch = "wasm32")]
        {
            // Call JS FFI to save to localStorage
            let key_bytes = name.as_bytes();
            let value_bytes = joined.as_bytes();
            unsafe {
                js_local_storage_set(
                    key_bytes.as_ptr(), key_bytes.len(),
                    value_bytes.as_ptr(), value_bytes.len()
                );
            }
            Ok(())
        }
        
        #[cfg(not(target_arch = "wasm32"))]
        {
            // Use the exact filename provided (no auto extension)
            let filename = name;
            
            std::fs::write(&filename, joined)
                .map_err(|e| format!("Failed to write to file {}: {}", filename, e))
        }
    }

    /// Loads a vector of strings from a file or local storage (for web)
    pub async fn load(name: &str) -> Result<Vec<String>, String> {
        #[cfg(target_arch = "wasm32")]
        {
            // Call JS FFI to load from localStorage
            let key_bytes = name.as_bytes();
            // Allocate a buffer for the value (max 16KB)
            let mut buf = vec![0u8; 16 * 1024];
            let len = unsafe {
                js_local_storage_get(
                    key_bytes.as_ptr(), key_bytes.len(),
                    buf.as_mut_ptr(), buf.len()
                )
            };
            if len == 0 {
                return Ok(Vec::new());
            }
            let content = String::from_utf8_lossy(&buf[..len]).to_string();
            Ok(content.lines().map(|s| s.to_string()).collect::<Vec<String>>())
        }
        
        #[cfg(not(target_arch = "wasm32"))]
        {
            // Use the exact filename provided (no auto extension)
            let filename = name;
            
            match std::fs::read_to_string(&filename) {
                Ok(content) => Ok(content.lines().map(|s| s.to_string()).collect()),
                Err(e) => {
                    if e.kind() == std::io::ErrorKind::NotFound {
                        Ok(Vec::new()) // Return empty vector if file doesn't exist yet
                    } else {
                        Err(format!("Failed to read file {}: {}", filename, e))
                    }
                }
            }
        }
    }

    /// Saves a vector of strings to a file or local storage (for web)
    /// Convenience method that takes Vec<&str> directly
    pub async fn save_strings<T: AsRef<str>>(name: &str, data: Vec<T>) -> Result<(), String> {
        let string_data: Vec<String> = data.into_iter()
            .map(|s| s.as_ref().to_string())
            .collect();
        Self::save(name, string_data).await
    }

    /// Saves a vector of numbers to a file or local storage (for web)
    /// Handles any type that can be converted to a string
    #[allow(dead_code)]
    pub async fn save_numbers<T: ToString>(name: &str, data: Vec<T>) -> Result<(), String> {
        let string_data: Vec<String> = data.into_iter()
            .map(|n| n.to_string())
            .collect();
        Self::save(name, string_data).await
    }

    /// Loads a vector of strings from a file or local storage (for web)
    /// Alias for load() for consistent naming with save_strings()
    pub async fn load_strings(name: &str) -> Result<Vec<String>, String> {
        Self::load(name).await
    }

    /// Loads a vector of numbers from a file or local storage (for web)
    /// Handles any type that can be parsed from a string
    #[allow(dead_code)]
    pub async fn load_numbers<T>(name: &str) -> Result<Vec<T>, String> 
    where
        T: std::str::FromStr,
    {
        let strings = Self::load(name).await?;
        
        let mut numbers = Vec::with_capacity(strings.len());
        for s in strings {
            match s.parse::<T>() {
                Ok(n) => numbers.push(n),
                Err(_) => return Err(format!("Failed to parse '{}' as number", s))
            }
        }
        
        Ok(numbers)
    }

    /// Loads an asset file (read-only data)
    #[allow(dead_code)]
    pub async fn load_asset(path: &str) -> Result<String, String> {
        match load_string(path).await {
            Ok(content) => Ok(content),
            Err(e) => Err(format!("Failed to load asset '{}': {:?}", path, e))
        }
    }
    
}