fable_format 0.1.1

A Rust library for using the assets of Fable, Fable: The Lost Chapters, Fable Anniversary, and mods.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::io::{Read,Seek,SeekFrom};

use nom::IResult;
use nom::number::complete::le_u32;
use nom::bytes::complete::{tag,take};
use nom::sequence::tuple;
use nom::multi::count;
use nom::combinator::all_consuming;

use chrono::naive::{NaiveDateTime,NaiveDate,NaiveTime};

use crate::{Decode,Error};
use crate::shared::decode_bytes_as_utf8_string;
use crate::Entry;

use super::{Wad,WadHeader,WadEntry};

impl Decode for Wad {
    fn decode<Source>(source: &mut Source) -> Result<Self, Error> where
        Source: Read + Seek
    {
        let mut header_buf = [0; 32];
        let mut entries_buf = Vec::new();

        source.read_exact(&mut header_buf)?;
        let (_, header) = all_consuming(Wad::decode_header)(&header_buf)?;

        source.seek(SeekFrom::Start(header.entries_offset as u64))?;
        source.read_to_end(&mut entries_buf)?;
        let (_, entries) = count(Wad::decode_entry, header.entries_count as usize)(&entries_buf)?;

        Ok(Wad { header: header, entries: entries })
    }
}

impl Wad {
    pub fn decode_header(input: &[u8]) -> IResult<&[u8], WadHeader, Error> {
        let (input, _magic_number) = tag("BBBB")(input)?;
        let (input, version) = tuple((le_u32, le_u32, le_u32))(input)?;
        let (input, block_size) = le_u32(input)?;
        let (input, entries_count) = le_u32(input)?;
        let (input, _entries_count_again) = le_u32(input)?;
        let (input, entries_offset) = le_u32(input)?;

        Ok(
            (
                input,
                WadHeader {
                    version: version,
                    block_size: block_size,
                    entries_count: entries_count,
                    entries_offset: entries_offset,
                }
            )
        )
    }

    pub fn decode_entry(input: &[u8]) -> IResult<&[u8], WadEntry, Error> {
        let (input, _unknown_1) = take(16usize)(input)?;
        let (input, id) = le_u32(input)?;
        let (input, _unknown_2) = le_u32(input)?;
        let (input, length) = le_u32(input)?;
        let (input, offset) = le_u32(input)?;
        let (input, _unknown_3) = le_u32(input)?;
        let (input, path_length) = le_u32(input)?;
        let (input, path) = take(path_length as usize)(input)?;

        let (_, path) = decode_bytes_as_utf8_string(path)?;

        let (input, _unknown_4) = take(16usize)(input)?;

        let (input, created) = Self::decode_timestamp(input)?;
        let (input, accessed) = Self::decode_timestamp(input)?;
        let (input, written) = Self::decode_short_timestamp(input)?;

        Ok(
            (
                input,
                WadEntry {
                    id: id,
                    length: length,
                    offset: offset,
                    path: path,
                    created: created,
                    accessed: accessed,
                    written: written,
                }
            )
        )
    }

    pub fn decode_timestamp(input: &[u8]) -> IResult<&[u8], NaiveDateTime, Error> {
        let (input, year) = le_u32(input)?;
        let (input, month) = le_u32(input)?;
        let (input, day) = le_u32(input)?;
        let (input, hour) = le_u32(input)?;
        let (input, minute) = le_u32(input)?;
        let (input, second) = le_u32(input)?;
        let (input, millisecond) = le_u32(input)?;

        let ymd = NaiveDate::from_ymd(year as i32, month, day);
        let hms = NaiveTime::from_hms_milli(hour, minute, second, millisecond);
        let date_time = NaiveDateTime::new(ymd, hms);

        Ok((input, date_time))
    }

    pub fn decode_short_timestamp(input: &[u8]) -> IResult<&[u8], NaiveDateTime, Error> {
        let (input, year) = le_u32(input)?;
        let (input, month) = le_u32(input)?;
        let (input, day) = le_u32(input)?;
        let (input, hour) = le_u32(input)?;
        let (input, minute) = le_u32(input)?;

        let ymd = NaiveDate::from_ymd(year as i32, month, day);
        let hms = NaiveTime::from_hms(hour, minute, 0);
        let date_time = NaiveDateTime::new(ymd, hms);

        Ok((input, date_time))
    }
}

impl Entry for WadEntry {
    fn len(&self) -> u64 { self.length as u64 }
    fn pos(&self) -> u64 { self.offset as u64 }
}