tgg 0.1.5

Library for reading TGG files used by Talon Games
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

use crate::{
    crossword::CrosswordData,
    utils::{calculate_checksum, extract_cstring_with_offset},
    Error, Footer, Game, GameData, Header, Metadata, TggFile,
};

pub fn load(bytes: Vec<u8>) -> Result<TggFile, Error> {
    // Validate and extract header
    if bytes.len() < 17 {
        return Err(Error::InsufficientHeaderBytes {
            min: 17,
            found: bytes.len() as u32,
        });
    }

    let header_bytes = &bytes[0..17];

    let id: String = header_bytes[0..14]
        .iter()
        .map(|&byte| byte as char)
        .collect();

    if id != "TalonGamesGame" {
        return Err(Error::InvalidID);
    }

    let game = match Game::from_byte(header_bytes[14]) {
        Some(game) => game,
        None => {
            return Err(Error::InvalidGameTypeByte {
                found: header_bytes[14],
            });
        }
    };
    let file_checksum = u16::from_le_bytes([header_bytes[15], header_bytes[16]]);

    let body = &bytes[17..bytes.len() - 2];

    // Extract metadata
    let (title, offset) = extract_cstring_with_offset(body, 0);
    let (description, offset) = extract_cstring_with_offset(body, offset);
    let (author, offset) = extract_cstring_with_offset(body, offset);

    if title.is_empty() {
        return Err(Error::TitleIsEmpty);
    }

    if description.is_empty() {
        return Err(Error::DescriptionIsEmpty);
    }

    if author.is_empty() {
        return Err(Error::AuthorIsEmpty);
    }

    // Validate metadata boundaries
    if offset + 6 > body.len() {
        return Err(Error::InsufficientMetadataBytes {
            expected: (offset + 6) as u32,
            found: body.len() as u32,
        });
    }

    let creation_date_bytes = &body[offset..offset + 4];
    let creation_date = u32::from_be_bytes(creation_date_bytes.try_into().unwrap());

    let checksum_bytes = &body[offset + 4..offset + 6];
    let gamedata_checksum = u16::from_le_bytes(checksum_bytes.try_into().unwrap());

    // Verify checksums
    let calculated_checksum = u16::from_le_bytes(calculate_checksum(body.to_vec()));
    let footer_file_checksum = u16::from_le_bytes([bytes[bytes.len() - 2], bytes[bytes.len() - 1]]);
    if file_checksum != calculated_checksum {
        return Err(Error::HeaderChecksumMismatch {
            expected: file_checksum,
            found: calculated_checksum,
        });
    }
    if file_checksum != footer_file_checksum {
        return Err(Error::HeaderChecksumMismatch {
            expected: file_checksum,
            found: footer_file_checksum,
        });
    }

    let game_data = &body[offset + 6..body.len()];
    if game_data.is_empty() {
        return Err(Error::GameDataIsEmpty);
    }

    let gamedata: GameData = match game {
        Game::Crossword => {
            let crossword_data = match CrosswordData::load(game_data) {
                Ok(crossword_data) => crossword_data,
                Err(err) => return Err(err),
            };

            GameData::Crossword(crossword_data)
        }
        Game::WordSearch => {
            unimplemented!()
        }
    };

    let header = Header::new(game, file_checksum);
    let metadata = Metadata::new(title, description, author, creation_date, gamedata_checksum);
    let footer = Footer::new(file_checksum);

    Ok(TggFile {
        header,
        metadata,
        gamedata,
        footer,
    })
}