Move Images Back to main()

/* jack.rs */

pub const JACK: &str = r"
' \ 0 /   '
'  \|/    '
'   |     '
'  / \    '
'_/   \_  '
'         '

'         '
' __0__   '
'/  |  \  '
'  / \    '
' _\ /_   '
'         '

'         '
'   o     '
' /\ /\   '
' |/ \|   '
' _\ /_   '
'         '

'         '
' __0__   '
'/  |  \  '
'  / \    '
' _\ /_   '
'         '
"; // end of JACK

pub fn parse_opts() -> (u64, bool, String, bool, &'static str) { // The constant has been copied into a &str value, which will disappear when
                                                                 // this function ends, preventing it from getting returned to the calling routine. So we
                                                                 // specify it as a 'static &str, which keeps it in existence for the lifetime of
                                                                 // the program.

...

    // Set "kind".
    let (kind, image) = match (&switches.kind.to_uppercase()).as_str() {  // Instead of the match returning one value, it returns two as a tuple.
//        "D" | "D51" => String::from("D51"), // Alternative way of doing '"D51".to_string()'.
//        "C" | "C51" => String::from("C51"),
//        "L" | "LITTLE" => String::from("LITTLE"),
        "J" | "JACK" => ( String::from("JACK"), crate::jack::JACK ), // Returning the String "JACK", and the image in the constant named "JACK"; returning both as a tuple.
//        "B" | "BOAT" => String::from("BOAT"),
//        "P" | "PLANE" => String::from("PLANE"),
        _ => {
            // If none of them match, then ...
            println!("Invalid input; run program with '--help' option for more information. You entered '{}', so the default of 'jack''d51' was used.", switches.kind);
//            String::from("D51") // While testing this setup, D51 is broken, so use Jack instead for now.
            ( String::from("JACK"), crate::jack::JACK )
        }
    };

    return (speed, switches.fly, kind, switches.oops, image);
} // end of parse_opts()

...
  mod jack;
...
  fn main() {
    let (speed, fly, kind, oops, image) = parse_opts(); // Get the program options from the command-line, if any.

  println!("{}", image);
//    draw_image(speed, fly, kind, oops);
} // end of main()

pub fn ampstr_to_vecvecstring(image_str: &str) -> Vec<Vec<String>> {
    /*  This function recieves a series of ASCII-art image "frames" in the variable "image_str", as one long
        string of UTF-8 characters (think of 'em as ASCII chars, though). This string is then broken down into
        separate lines, breaking at the newline/end-of-line characters, and each line is converted from a &str
        into a String, and then pushed onto a vector of Strings. When a blank line is found, signifying the end
        of one frame and the beginning of another, we skip on to the next loop, and create a new vector at the
        same time, and then repeat the above process, pushing the next frame into this new vector. Eventually,
        each of the image frames is put into its own vector, and all these vectors are put into an outer vector.
    */

    let mut outer_vec: Vec<Vec<String>> = Vec::new();               // Outer vec holding all the inner frame vecs.
    outer_vec.push(Vec::new());                                     // Create first inner_image_frame vec, and push it into the outer_vec.

    let mut inner_image_frame: usize = 0;                                 // To keep track of which image frame vector we're working with. First = 0.
    
    // Process each line of the image_str.
    for each_line in image_str.lines() {                            // Break the &str into lines at the newline.
        if each_line != "" {                                        // If the line is not blank...
            each_line.replace("'", " ");                            // ... replace the single-quotes with spaces, and ...
            let line_string = each_line.to_string();                // ... convert the &str variable to a String variable.
            outer_vec[inner_image_frame].push(line_string);         // Then push that String into the current inner inner_image_frame vec.
        } else {                                                    // Else, if the line is blank, ignore it, and ...
            inner_image_frame += 1;                                 // ... count a new inner inner_image_frame vec, and then ...
            outer_vec.push(Vec::new());                             // ... create that new inner inner_image_frame vec.
        }
    }
    return outer_vec;
} // end of ampstr_to_vecvecstring()

fn main() {
    let (speed, fly, kind, oops, image_str) = parse_opts();
    let image_vec = ampstr_to_vecvecstr(image_str);
    // "draw_image(speed, fly, kind, oops, image_vec)
} // end of main()

fn main() {
    let (speed, fly, kind, oops, image_str) = parse_opts();
println!("{:?}", image_str);
    println!("Above is the amperstring");
    let image_vec = ampstr_to_vecvecstring(image_str);
    println!("Below is the converted vecvecstring");
println!("{:?}", image_vec);
    // draw_image(speed, fly, kind, oops, image_vec)
} // end of main()

pub fn ampstr_to_vecvecstring(image_str: &str) -> Vec<Vec<String>> {
    /*  This function recieves a series of ASCII-art image "inner_vecs" in the variable "image_str", as one long
        string of UTF-8 characters (think of 'em as ASCII chars, though). This string is then broken down into
        separate lines, breaking at the newline/end-of-line characters, and each line is converted from a &str
        into a String, and then pushed onto a vector of Strings. When a blank line is found, signifying the end
        of one inner_vec and the beginning of another, we skip on to the next loop, and create a new vector at the
        same time, and then repeat the above process, pushing the next inner_vec into this new vector. Eventually,
        each of the image inner_vecs is put into its own vector, and all these vectors are put into an outer vector.
    */

    // The const for the ASCII-art image needs to be cleaned up; for that, we need a mutable String.
    let mut image_string = image_str.to_owned();

    // The const for the ASCII-art image has unwanted single-quotes; let's remove those.
    image_string = image_string.replace("'", "");

    // The const for the ASCII-art image has an unwanted newline at the top of the string; let's remove that.
//    image_string.remove(0);       // This seems to cause problems; I'm not sure what's going on, and am too lazy to investigate.

    // And finally, let's put a trailing space on each line;
    image_string.replace("\n", " \n");

    let mut outer_vec: Vec<Vec<String>> = Vec::new(); // Outer vec holding all the inner inner_vec vecs.
    outer_vec.push(Vec::new()); // Create first inner_vec, and push it into the outer_vec.

    let mut inner_vec: usize = 0; // To keep track of which image inner_vec vector we're working with. First = 0.

    // Process each line of the image_string.
    for each_line in image_string.lines() {
        // Break the string into lines at the newline.
        if each_line != "" {
            // If the line is not blank...
            outer_vec[inner_vec].push(line_string); // ... then convert that line to a String and push it into the current inner_vec.
        } else {
            // Else, if the line is blank, ignore it, and ...
            nner_vec += 1; // ... count a new inner inner_vec, and then ...
            outer_vec.push(Vec::new()); // ... create that new inner_vec.
        }
    }
    return outer_vec;
} // end of ampstr_to_vecvecstring()

fn main() {
    let (speed, fly, kind, oops, image_str) = parse_opts();
println!("{:?}", image_str);
    println!("Above is the amperstring");
    let image_vec = ampstr_to_vecvecstring(image_str);
    println!("Below is the converted vecvecstring");
println!("{:?"}, image_vec);
for every_frame in &image_vec {
  for every_line in every_frame {
    println!("{}", every_line);
  }
}
    // draw_image(speed, fly, kind, oops, image_vec)
} // end of main()

pub fn draw_image(delay: u64, fly: bool, kind: String, oops: bool, image_vec: Vec<Vec<String>>) {
    initscr(); // Start ncurses, initializing "stdscr()".
    noecho(); // Don't echo keypresses to screen.
    curs_set(CURSOR_VISIBILITY::CURSOR_INVISIBLE); // Turn off the display of the cursor.

    // Get the screen dimensions.
    let (mut screen_height, mut screen_width) = (0, 0);
    getmaxyx(stdscr(), &mut screen_height, &mut screen_width); // Dims are now in screen_height/width.

    // Load ASCII-art into "image" variable (a vector of vectors holding strings).
    let mut image: Vec<Vec<String>> = vec![vec!["".to_string()]];
    image = match kind.as_str() {
        "D51" => get_d51(),
        // "C51" => get_image("src/c51.txt"),
        // "LITTLE" => get_image("src/little.txt"),
        //   	"JACK" => get_image(jack::jack),
        // "BOAT" => get_boat(),
        // "PLANE" => get_plane(),
        &_ => {
            println!(
                "Invalid kind; you entered {}. The default of 'D51' was used instead.",
                kind
            );
            get_d51()
        }
    };

    let frames = image.len() as i32; // How many animation cel frames in this image?
    let count_of_inner_vecs = image.len() as i32; // How many animation cel inner_vecs in this image?
    let length = image[0][0].len() as i32; // How long (width in screen columns/chars) is the train?
    let height = image[0].len() as i32; // How tall is the train?
    let mut row = screen_height - height; // We'll draw the train at the bottom of the screen.
    let ms = Duration::from_millis(delay); // We'll be pausing this many milliseconds between frames.

    let mut inner_vec = count_of_inner_vecs - 1; // Let's start with the highest-numbered inner_vec, & count down. This will fix the "reverse" issue.
    for col in ((-length)..screen_width).rev() {
        //Count down from right-edge until nose of train drags all of train off left-edge.
        let mut line = row; // "line" of ASCII-art to display; "row" is where.
        let current_inner_vec = &image_vec[inner_vec as usize]; // Strings are referenced by a usize, so here's another conversion.
        for each_line in current_inner_vec {
            my_mvaddstr(line, col, &each_line, screen_width, screen_height); // Display each line of the inner_vec.
            line = line + 1; // Move to next row for next line of ASCII-art.
        }
        refresh(); // Display the image.
        thread::sleep(ms); // Pause to let our eyes register the image.
        inner_vec = inner_vec - 1; // Prepare to display next inner_vec.
        if inner_vec < 0 {
            // If we've gotten down to last inner_vec...
            inner_vec = count_of_inner_vecs - 1; // ... start over.
            if fly {
                // And check to see if we're flying. If so...
                line = -1 + row + height; // ... erase last (bottom) line drwn with enough repeated spaces fo train's length.
                my_mvaddstr(
                    line,
                    col,
                    &" ".repeat(length as usize),
                    screen_width,
                    screen_height,
                ); // No need to refresh(); next inner_vec will do it for us.
                row -= 1; // ... raise the next drawing one row up.
            }
        }
    }

    /* Once finished, terminate ncurses. */
    endwin();
} // end of draw_image()

fn main() {
    let (speed, fly, kind, oops, image_str) = parse_opts();
    let image_vec = ampstr_to_vecvecstring(image_str);
for every_frame in &image_vec {
  for every_line in every_frame {
    println!("{}", every_line);
  }
}
    // draw_image(speed, fly, kind, oops, image_vec)
} // end of main()