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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
#include "MessageFactory.h"
#include "utils/Decompressor.h"
#include "spdlog/spdlog.h"
#include "Companion.h"
#define END_CODE 0x0
#define NEWLINE_CODE 0x1
#define SPC 15
#define CLF 16
#define CUP 17
#define CRT 18
#define CDN 19
#define AUP 20
#define ALF 21
#define ADN 22
#define ART 23
#define EXM 50
#define QST 51
#define DSH 52
#define CMA 53
#define PRD 54
#define APS 55
#define LPR 56
#define RPR 57
#define CLN 58
#define PIP 59
std::vector<std::string> gCharCodeEnums = {
"END", "NWL", "NP2", "NP3", "NP4", "NP5", "NP6", "NP7",
"PRI0", "PRI1", "PRI2", "PRI3", "SPC", "HSP", "QSP", "NXT",
"CLF", "CUP", "CRT", "CDN", "AUP", "ALF", "ADN", "ART",
"_A", "_B", "_C", "_D", "_E", "_F", "_G", "_H",
"_I", "_J", "_K", "_L", "_M", "_N", "_O", "_P",
"_Q", "_R", "_S", "_T", "_U", "_V", "_W", "_X",
"_Y", "_Z", "_a", "_b", "_c", "_d", "_e", "_f",
"_g", "_h", "_i", "_j", "_k", "_l", "_m", "_n",
"_o", "_p", "_q", "_r", "_s", "_t", "_u", "_v",
"_w", "_x", "_y", "_z", "EXM", "QST", "DSH", "CMA",
"PRD", "_0", "_1", "_2", "_3", "_4", "_5", "_6",
"_7", "_8", "_9", "APS", "LPR", "RPR", "CLN", "PIP",
};
std::unordered_map<std::string, std::string> ASCIITable = {
{ "CLF", "(C<)" }, { "CUP", "(C^)" }, { "CRT", "(C>)" }, { "CDN", "(Cv)" },
{ "AUP", "^" }, { "ALF", "<" }, { "ADN", "v" }, { "ART", ">" },
{ "EXM", "!" }, { "QST", "?" }, { "DSH", "-" }, { "CMA", "," },
{ "PRD", "." }, { "APS", "'" }, { "LPR", "(" }, { "RPR", ")" },
{ "CLN", ":" }, { "PIP", "| " }
};
ExportResult SF64::MessageHeaderExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement) {
const auto symbol = GetSafeNode(node, "symbol", entryName);
if(Companion::Instance->IsOTRMode()){
write << "static const char " << symbol << "[] = \"__OTR__" << (*replacement) << "\";\n\n";
return std::nullopt;
}
write << "extern u16 " << symbol << "[];\n";
return std::nullopt;
}
void TextToStream(std::ostream& stream, int charCode) {
std::string enumCode = gCharCodeEnums[charCode];
if(enumCode.starts_with("_")){
stream << enumCode.substr(1);
return;
}
if(ASCIITable.contains(enumCode)){
stream << ASCIITable[enumCode];
}
}
ExportResult SF64::MessageCodeExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
auto message = std::static_pointer_cast<MessageData>(raw)->mMessage;
const auto symbol = GetSafeNode(node, "symbol", entryName);
auto offset = GetSafeNode<uint32_t>(node, "offset");
write << "// ";
bool lastWasSpace = false;
for (int i = 0; i < message.size(); ++i) {
const auto charCode = message[i];
std::string enumCode = gCharCodeEnums[charCode];
if(enumCode.find("SP") != std::string::npos){
if (lastWasSpace){
continue;
}
if (!enumCode.empty() && enumCode.back() != ' ') {
write << " ";
lastWasSpace = true;
}
} else {
lastWasSpace = false;
}
TextToStream(write,charCode );
if(message[i] == NEWLINE_CODE && i != message.size() - 2){
write << "\n// ";
}
}
write << "\n";
write << "u16 " << symbol << "[] = {\n" << fourSpaceTab;
for (int i = 0; i < message.size(); ++i) {
auto m = message[i];
write << gCharCodeEnums[m] << ", ";
if(m == NEWLINE_CODE){
write << "\n" << fourSpaceTab;
}
}
write << "\n};\n";
if (Companion::Instance->IsDebug()) {
write << "// count: " << std::to_string(message.size()) << " chars\n";
}
return offset + message.size() * sizeof(uint16_t);
}
ExportResult SF64::MessageBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
auto writer = LUS::BinaryWriter();
const auto data = std::static_pointer_cast<MessageData>(raw);
WriteHeader(writer, LUS::ResourceType::Message, 0);
writer.Write(static_cast<uint32_t>(data->mMessage.size()));
for(auto m : data->mMessage) {
writer.Write(m);
}
writer.Finish(write);
return std::nullopt;
}
std::optional<std::shared_ptr<IParsedData>> SF64::MessageFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
std::vector<uint16_t> message;
auto [_, segment] = Decompressor::AutoDecode(node, buffer);
LUS::BinaryReader reader(segment.data, segment.size);
reader.SetEndianness(LUS::Endianness::Big);
uint16_t c = reader.ReadUInt16();
while(c != END_CODE){
message.push_back(c);
c = reader.ReadUInt16();
}
message.push_back(END_CODE);
return std::make_shared<MessageData>(message);
}
|
