rust snippet

use std::fs::File;
use std::io::prelude::*;
use std::mem;
use byteorder::{BigEndian, WriteBytesExt};
extern crate hex;

fn main() {
    let mut file = File::open("q3_cor.gci").expect("Can't open file!");
    let mut buffer = Vec::new();

    // Read the file into vector
    file.read_to_end(&mut buffer)
        .expect("Couldn't read file.");

    // Create buffers for questlogs
    let qlog_1_buffer = &buffer[16456..19156];
    let qlog_2_buffer = &buffer[19164..21864];
    let qlog_3_buffer = &buffer[21872..24572];
    let qlog_1_shadow_buffer = &buffer[24648..27348];
    let qlog_2_shadow_buffer = &buffer[27356..30056];
    let qlog_3_shadow_buffer = &buffer[30064..32764];
    let gci_buffer = &buffer[0..32824];

    // Questlog checksums
    let qlog_1_checksum = &buffer[19156..19164];
    let qlog_2_checksum = &buffer[21864..21872];
    let qlog_3_checksum = &buffer[24572..24580];
    let qlog_1_shadow_checksum = &buffer[27348..30056];
    let qlog_2_shadow_checksum = &buffer[30056..32764];
    let qlog_3_shadow_checksum = &buffer[32764..32772];

    // convert to hex for testing
    build_checksum(qlog_1_buffer);
    let test = hex::encode(qlog_1_buffer);

    //println!("The bytes: {:?}", test);
}

fn build_checksum(buf: &[u8]) {
    let mut sum: u32 = 0;
    let mut x: u32 = 0;
    let mut done = false; // mut done: bool

    while !done {
        sum += (buf[x as usize] as u32);
        //println!("index: {0}, value: {1}", x, sum);

        if x == ((buf.len() - 1) as u32) {
            done = true;
        }
        x = x + 1;
    }

    sum = sum + (buf.len() as u32);
    let neg_sum: u32 = sum.wrapping_neg();
    println!("buf.len: {0}, total: {1}, neg_total: {2}", buf.len(), sum, neg_sum);

    let mut be_sum = [0u8; mem::size_of::<u32>()];
    be_sum.as_mut()
        .write_u32::<BigEndian>(sum)
        .expect("Unable to write");

    let mut be_neg_sum = [0u8; mem::size_of::<u32>()];
    be_neg_sum.as_mut()
        .write_u32::<BigEndian>(neg_sum)
        .expect("Unable to write");

    for i in &be_sum {
        println!("{:X}", i);
    }

    for i in &be_neg_sum {
        println!("{:X}", i)
    }

    //let mut checksum: (u32, u32) = (BigEndian::from_slice_u32(&mut sum), neg_sum);

    //println!("Checksum: {:?}", checksum);
}