liblcf
Loading...
Searching...
No Matches
lmu_movecommand.cpp
Go to the documentation of this file.
1/*
2 * This file is part of liblcf. Copyright (c) liblcf authors.
3 * https://github.com/EasyRPG/liblcf - https://easyrpg.org
4 *
5 * liblcf is Free/Libre Open Source Software, released under the MIT License.
6 * For the full copyright and license information, please view the COPYING
7 * file that was distributed with this source code.
8 */
9
10#include "lcf/rpg/movecommand.h"
11#include "reader_struct.h"
12#include <iostream>
13
14namespace lcf {
15
16template <>
17struct RawStruct<rpg::MoveCommand> {
18 static void ReadLcf(rpg::MoveCommand& ref, LcfReader& stream, uint32_t length);
19 static void WriteLcf(const rpg::MoveCommand& ref, LcfWriter& stream);
20 static int LcfSize(const rpg::MoveCommand& ref, LcfWriter& stream);
21 static void WriteXml(const rpg::MoveCommand& ref, XmlWriter& stream);
22 static void BeginXml(rpg::MoveCommand& ref, XmlReader& stream);
23};
24
25template <>
26struct RawStruct<std::vector<rpg::MoveCommand> > {
27 static void ReadLcf(std::vector<rpg::MoveCommand>& ref, LcfReader& stream, uint32_t length);
28 static void WriteLcf(const std::vector<rpg::MoveCommand>& ref, LcfWriter& stream);
29 static int LcfSize(const std::vector<rpg::MoveCommand>& ref, LcfWriter& stream);
30 static void WriteXml(const std::vector<rpg::MoveCommand>& ref, XmlWriter& stream);
31 static void BeginXml(std::vector<rpg::MoveCommand>& ref, XmlReader& stream);
32};
33
37void RawStruct<rpg::MoveCommand>::ReadLcf(rpg::MoveCommand& ref, LcfReader& stream, uint32_t /* length */) {
38 ref.command_id = stream.ReadInt();
39 const auto cmd = static_cast<rpg::MoveCommand::Code>(ref.command_id);
40 switch (cmd) {
41 case rpg::MoveCommand::Code::switch_on:
42 stream.Read(ref.parameter_a);
43 break;
44 case rpg::MoveCommand::Code::switch_off:
45 stream.Read(ref.parameter_a);
46 break;
47 case rpg::MoveCommand::Code::change_graphic:
48 stream.ReadString(ref.parameter_string, stream.ReadInt());
49 stream.Read(ref.parameter_a);
50 break;
51 case rpg::MoveCommand::Code::play_sound_effect:
52 stream.ReadString(ref.parameter_string, stream.ReadInt());
53 stream.Read(ref.parameter_a);
54 stream.Read(ref.parameter_b);
55 stream.Read(ref.parameter_c);
56 break;
57 default: break;
58 }
59}
60
61void RawStruct<rpg::MoveCommand>::WriteLcf(const rpg::MoveCommand& ref, LcfWriter& stream) {
62 stream.WriteInt(ref.command_id);
63 const auto cmd = static_cast<rpg::MoveCommand::Code>(ref.command_id);
64 switch (cmd) {
65 case rpg::MoveCommand::Code::switch_on:
66 stream.Write(ref.parameter_a);
67 break;
68 case rpg::MoveCommand::Code::switch_off:
69 stream.Write(ref.parameter_a);
70 break;
71 case rpg::MoveCommand::Code::change_graphic:
72 stream.WriteInt(stream.Decode(ref.parameter_string).size());
73 stream.Write(ref.parameter_string);
74 stream.Write(ref.parameter_a);
75 break;
76 case rpg::MoveCommand::Code::play_sound_effect:
77 stream.WriteInt(stream.Decode(ref.parameter_string).size());
78 stream.Write(ref.parameter_string);
79 stream.Write(ref.parameter_a);
80 stream.Write(ref.parameter_b);
81 stream.Write(ref.parameter_c);
82 break;
83 default: break;
84 }
85}
86
87int RawStruct<rpg::MoveCommand>::LcfSize(const rpg::MoveCommand& ref, LcfWriter& stream) {
88 int result = 0;
89 result += LcfReader::IntSize(ref.command_id);
90 const auto cmd = static_cast<rpg::MoveCommand::Code>(ref.command_id);
91 switch (cmd) {
92 case rpg::MoveCommand::Code::switch_on:
93 result += LcfReader::IntSize(ref.parameter_a);
94 break;
95 case rpg::MoveCommand::Code::switch_off:
96 result += LcfReader::IntSize(ref.parameter_a);
97 break;
98 case rpg::MoveCommand::Code::change_graphic:
99 result += LcfReader::IntSize(stream.Decode(ref.parameter_string).size());
100 result += stream.Decode(ref.parameter_string).size();
101 result += LcfReader::IntSize(ref.parameter_a);
102 break;
103 case rpg::MoveCommand::Code::play_sound_effect:
104 result += LcfReader::IntSize(stream.Decode(ref.parameter_string).size());
105 result += stream.Decode(ref.parameter_string).size();
106 result += LcfReader::IntSize(ref.parameter_a);
107 result += LcfReader::IntSize(ref.parameter_b);
108 result += LcfReader::IntSize(ref.parameter_c);
109 break;
110 default: break;
111 }
112 return result;
113}
114
115void RawStruct<rpg::MoveCommand>::WriteXml(const rpg::MoveCommand& ref, XmlWriter& stream) {
116 stream.BeginElement("MoveCommand");
117 stream.WriteNode("command_id", ref.command_id);
118 const auto cmd = static_cast<rpg::MoveCommand::Code>(ref.command_id);
119 switch (cmd) {
120 case rpg::MoveCommand::Code::switch_on:
121 stream.WriteNode("parameter_a", ref.parameter_a);
122 break;
123 case rpg::MoveCommand::Code::switch_off:
124 stream.WriteNode("parameter_a", ref.parameter_a);
125 break;
126 case rpg::MoveCommand::Code::change_graphic:
127 stream.WriteNode("parameter_string", ref.parameter_string);
128 stream.WriteNode("parameter_a", ref.parameter_a);
129 break;
130 case rpg::MoveCommand::Code::play_sound_effect:
131 stream.WriteNode("parameter_string", ref.parameter_string);
132 stream.WriteNode("parameter_a", ref.parameter_a);
133 stream.WriteNode("parameter_b", ref.parameter_b);
134 stream.WriteNode("parameter_c", ref.parameter_c);
135 break;
136 default: break;
137 }
138 stream.EndElement("MoveCommand");
139}
140
141class MoveCommandXmlHandler : public XmlHandler {
142private:
143 rpg::MoveCommand& ref;
146public:
149 void StartElement(XmlReader& stream, const char* name, const char** /* atts */) {
150 if (strcmp(name, "command_id") == 0)
151 field = &ref.command_id;
152 else if (strcmp(name, "parameter_a") == 0)
153 field = &ref.parameter_a;
154 else if (strcmp(name, "parameter_b") == 0)
155 field = &ref.parameter_b;
156 else if (strcmp(name, "parameter_c") == 0)
157 field = &ref.parameter_c;
158 else if (strcmp(name, "parameter_string") == 0)
159 parameter_string = true;
160 else {
161 stream.Error("Unrecognized field '%s'", name);
162 field = NULL;
163 parameter_string = false;
164 }
165 }
166 void EndElement(XmlReader& /* stream */, const char* /* name */) {
167 field = NULL;
168 parameter_string = false;
169 }
170 void CharacterData(XmlReader& /* stream */, const std::string& data) {
171 if (field != NULL)
172 XmlReader::Read(*field, data);
173 else if (parameter_string)
174 XmlReader::Read(ref.parameter_string, data);
175 }
176};
177
179 stream.SetHandler(new WrapperXmlHandler("MoveCommand", new MoveCommandXmlHandler(ref)));
180}
181
185void RawStruct<std::vector<rpg::MoveCommand> >::ReadLcf(std::vector<rpg::MoveCommand>& ref, LcfReader& stream, uint32_t length) {
186 unsigned long startpos = stream.Tell();
187 unsigned long endpos = startpos + length;
188 while (stream.Tell() != endpos) {
189 rpg::MoveCommand command;
191 ref.push_back(command);
192 }
193}
194
195void RawStruct<std::vector<rpg::MoveCommand> >::WriteLcf(const std::vector<rpg::MoveCommand>& ref, LcfWriter& stream) {
196 std::vector<rpg::MoveCommand>::const_iterator it;
197 for (it = ref.begin(); it != ref.end(); it++)
199}
200
201int RawStruct<std::vector<rpg::MoveCommand> >::LcfSize(const std::vector<rpg::MoveCommand>& ref, LcfWriter& stream) {
202 int result = 0;
203 std::vector<rpg::MoveCommand>::const_iterator it;
204 for (it = ref.begin(); it != ref.end(); it++)
206 return result;
207}
208
209void RawStruct<std::vector<rpg::MoveCommand> >::WriteXml(const std::vector<rpg::MoveCommand>& ref, XmlWriter& stream) {
210 std::vector<rpg::MoveCommand>::const_iterator it;
211 for (it = ref.begin(); it != ref.end(); it++)
213}
214
215class MoveCommandVectorXmlHandler : public XmlHandler {
216public:
217 MoveCommandVectorXmlHandler(std::vector<rpg::MoveCommand>& ref) : ref(ref) {}
218
219 void StartElement(XmlReader& stream, const char* name, const char** /* atts */) {
220 if (strcmp(name, "MoveCommand") != 0)
221 stream.Error("Expecting %s but got %s", "MoveCommand", name);
222 ref.resize(ref.size() + 1);
223 rpg::MoveCommand& obj = ref.back();
224 stream.SetHandler(new MoveCommandXmlHandler(obj));
225 }
226private:
227 std::vector<rpg::MoveCommand>& ref;
228};
229
230void RawStruct<std::vector<rpg::MoveCommand> >::BeginXml(std::vector<rpg::MoveCommand>& obj, XmlReader& stream) {
231 stream.SetHandler(new MoveCommandVectorXmlHandler(obj));
232}
233
234} //namspace lcf
std::vector< rpg::MoveCommand > & ref
void StartElement(XmlReader &stream, const char *name, const char **)
MoveCommandVectorXmlHandler(std::vector< rpg::MoveCommand > &ref)
void CharacterData(XmlReader &, const std::string &data)
void EndElement(XmlReader &, const char *)
MoveCommandXmlHandler(rpg::MoveCommand &ref)
void StartElement(XmlReader &stream, const char *name, const char **)
RootXmlHandler(S &ref, const char *const name)
static void WriteXml(const T &ref, XmlWriter &stream)
static void BeginXml(T &ref, XmlReader &stream)
static void ReadLcf(T &ref, LcfReader &stream, uint32_t length)
static void WriteLcf(const T &ref, LcfWriter &stream)
static int LcfSize(const T &ref, LcfWriter &stream)