Add the C51 Train

/* extras.rs */

use ncurses::*;
use std::{thread, time::Duration};
use crate::d51::*;
...

pub fn draw_d51draw_image(delay: u64, fly:bool, oops:bool) {
  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.
    
  let d51image = get_d51();
  let frames = d51image.len() as i32;            // How many animation cel frames in this image?
  let length = d51image[0][0].len() as i32;      // How long (width in screen columns/chars) is the train?
  let height = d51image[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 frame = frames - 1;               // Let's start with the highest-numbered frame, & 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_frame=&d51image[frame as usize]; // Strings are referenced by a usize, so here's another conversion.
    for each_line in current_frame {
      my_mvaddstr(line, col, &each_line, screen_width, screen_height);   // Display each line of the frame.
      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.
    frame = frame - 1;                      // Prepare to display next frame.
    if frame < 0 {                          // If we've gotten down to last frame...
      frame = frames - 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 frame will do it for us.
        row -=1;                            // ... raise the next drawing one row up.
      }
    }
  }

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

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

    match kind.as_str() {                       
      "D51" => draw_d51(speed, fly, oops),
      "C51" => draw_c51(),
      &_ => println!("nope"),
    }
  draw_image(speed, fly, kind, oops);
} // end of main()

pub fn draw_image(delay: u64, fly:bool, kind:String, oops:bool) {            // The function is now receiving four items, including the "kind" of image to draw.
    // Start ncurses, initializing "stdscr()".
    initscr();

    // Don't echo keypresses to screen.
    noecho();

    // Turn off the display of the cursor.
    curs_set(CURSOR_VISIBILITY::CURSOR_INVISIBLE);

    // Get the screen dimensions.
    let mut screen_height = 0;
    let mut screen_width = 0;
    getmaxyx(stdscr(), &mut screen_height, &mut screen_width);

  let image: Vec<Vec^lt;String>> = get_d51();

  // Load ASCII-art into "image" variable (a vector of vectors holding Strings).
  let image = match kind.as_str() {                                               // Which image are we supposed to draw?
    "D51" => get_d51(),                                                           // D51 is the only one that currently works.
    // "C51" => get_c51(),
    &_ => {                                                                       // If the user enters an unknown image name (say, "racecar") ...
            println!("Invalid kind. You entered '{}'; the default was used instead.", kind);
            get_d51()
          },
  };
  
    let height = image[0].len() as i32; // How tall (in rows) is the D51image?
    let mut row = screen_height - height; // Put the wheelsbottom of image at the bottom of the screen.
    let count_of_inner_vecs: usize = image.len(); // How many animation cel frames in this image?
    let length: i32 = image[0][0].len() as i32; // How long (width in screen columns/chars) is the trainimage?
    let ms = Duration::from_millis(delay); // This is the "delay" converted to a format for the "sleep()" function below.

    let mut current_inner_vec: usize = count_of_inner_vecs - 1; // Count down from highest-numbered frame; then repeat cycle.

    for col in ((-length)..screen_width).rev() {
        // Count down from right-edge until nose of trainleading edge of image drags all of trainimage off left-edge.
        let current_frame = &image[current_inner_vec]; // Of the various inner_vecs, get the one we're drawing into its own variable.
        let mut line = row; // Keep "row" unaltered unless we're flying; use "line" within loop.
        for each_line in current_frame {
            my_mvaddstr(line, col, &each_line, screen_width, screen_height);
            line = line + 1;
        }
        refresh(); // Necessary to "bring to the forefront" the drawing we just did "in the back staging area".

        /* Pause so our eyes can see the frame. */
        thread::sleep(ms);
        // row = screen_height - height; // Reset row back to starting row.

        if current_inner_vec > 0 {
            current_inner_vec = current_inner_vec - 1; // Prepare to display next frame.
        } else {
            // we've gotten down to last frame, so ...
            current_inner_vec = count_of_inner_vecs - 1; // ... start over.
            if fly {
                // And if we're flying ...
                row -= 1; // ... fly up one row, and ...
                line = row + height; // ... erase last (bottom) line drawn, using enough repeated spaces for trainimage's length.
                my_mvaddstr(
                    line,
                    col,
                    &" ".repeat(length as usize),
                    screen_width,
                    screen_height,
                );
                // No need to refresh(); next frame will do it for us.
            }
        }
    }
    /* Once finished, terminate ncurses. */
    endwin();
} // end of draw_image()

/* c51.rs */

pub fn draw_c51() {
  println!("This is the 'c51' module.");
pub fn get_c51() -> Vec<Vec<String>> {
   /*  This function reads a text file containing a series of ASCII-art image "frames". This gets put into a
        variable 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
        pushed onto an inner vector, named "inner_vec[the number of the vec]". When a blank line is found, we
        skip on to the next loop, and create a new inner vector at the same time, and then repeat the above
        process. Eventually, each of the image frames is put into its own inner vector, and all those inner
        vectors are put into an outer vector named "outer_vec".
    */

    let mut outer_vec: Vec<Vec<String>> = Vec::new(); // Outer vec holding all the inner frame vecs.

    // Read the file containing the image, into a variable named "image_string".
    let image_string = std::fs::read_to_string("src/c51.txt").expect("Error opening file.");

    let mut inner_vec: usize = 0; // To keep track of which frame/inner vector we're working with.
    
    outer_vec.push(Vec::new()); // Create first inner frame vec and push it into outer vec.

    // Process each line of the text file that's been read into memory.
    for each_line in image_string.lines() { // Break-up the single String variable "image_string" at newlines.
        if each_line != "" {
            // If the line is not blank,
            outer_vec[inner_vec].push(each_line.to_string()) // copy the line into the current inner frame vec.
        } else {
            // Else, if the line is blank, then we're between frames, so ignore the blan line, and
            inner_vec += 1; // prep for a new inner frame vec, and then
            outer_vec.push(Vec::new()); // create that new inner frame vec,
        } // before looping around to the next line.
    }
    
    return outer_vec;

} // end of drawget_c51()

...
   // Process each line of the text file that's been read into memory.
    for each_line in image_string.lines() {                   // Break-up the single String variable "image_string" at newlines.
        if each_line != "" {                                  // If the line is not blank,
            outer_vec[inner_vec].push(each_line.to_string())  // copy the line into the current inner frame vec.
            let line_string = each_line.replace("\"", " ").to_string(); // replace quotes with spaces, & convert the &str variable to a String variable
            outer_vec[inner_vec].push(line_string);             // Then copy that String into the current inner frame vec.
        } else {
            // Else, if the line is blank, then we're between frames, so ignore the blank line, and
            inner_vec += 1; // prep for a new inner frame vec, and then
            outer_vec.push(Vec::new()); // create that new inner frame vec,
        } // before looping around to the next line.