liblcf
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 
14 namespace lcf {
15 
16 template <>
17 struct 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 
25 template <>
26 struct 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 
37 void 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 
61 void 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 
87 int 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 
115 void 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 
141 class MoveCommandXmlHandler : public XmlHandler {
142 private:
143  rpg::MoveCommand& ref;
144  int32_t* field;
146 public:
147  MoveCommandXmlHandler(rpg::MoveCommand& ref) :
148  ref(ref), field(NULL), parameter_string(false) {}
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 
178 void RawStruct<rpg::MoveCommand>::BeginXml(rpg::MoveCommand& ref, XmlReader& stream) {
179  stream.SetHandler(new WrapperXmlHandler("MoveCommand", new MoveCommandXmlHandler(ref)));
180 }
181 
185 void 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;
190  RawStruct<rpg::MoveCommand>::ReadLcf(command, stream, 0);
191  ref.push_back(command);
192  }
193 }
194 
195 void 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 
201 int 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++)
205  result += RawStruct<rpg::MoveCommand>::LcfSize(*it, stream);
206  return result;
207 }
208 
209 void 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 
215 class MoveCommandVectorXmlHandler : public XmlHandler {
216 public:
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  }
226 private:
227  std::vector<rpg::MoveCommand>& ref;
228 };
229 
230 void 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 **)
Definition: dbarray.cpp:13
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)