← Back to branch summary

~ubuntu-branches/ubuntu/raring/simutrans/raring-proposed

« back to all changes in this revision

Viewing changes to besch/writer/crossing_writer.cc

  • Committer: Package Import Robot
  • Author(s): Ansgar Burchardt
  • Date: 2011-11-03 19:59:02 UTC
  • mfrom: (1.2.7)
  • Revision ID: package-import@ubuntu.com-20111103195902-uopgwf488mfctb75
Tags: 111.0-1
* New upstream release.
* debian/rules: Update get-orig-source target for new upstream release.
* Use xz compression for source and binary packages.
* Use override_* targets to simplify debian/rules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
besch/writer/crossing_writer.cc
15
15
 
16
16
using std::string;
17
17
 
 
18
static void make_list(tabfileobj_t const& obj, slist_tpl<string>& list, char const* const key)
 
19
{
 
20
        for (int i = 0;; ++i) {
 
21
                char buf[40];
 
22
                sprintf(buf, "%s[%i]", key, i);
 
23
                string str(obj.get(buf));
 
24
                if (str.empty()) break;
 
25
                // We have this direction
 
26
                list.append(str);
 
27
        }
 
28
}
 
29
 
 
30
static void write_list(FILE* const fp, obj_node_t& node, slist_tpl<string> const& list)
 
31
{
 
32
        if (list.empty()) {
 
33
                xref_writer_t::instance()->write_obj(fp, node, obj_imagelist, "", false);
 
34
        } else {
 
35
                imagelist_writer_t::instance()->write_obj(fp, node, list);
 
36
        }
 
37
}
 
38
 
18
39
void crossing_writer_t::write_obj(FILE* fp, obj_node_t& parent, tabfileobj_t& obj)
19
40
{
20
41
        int total_len = 21;
22
43
        // prissi: must be done here, since it may affect the len of the header!
23
44
        string sound_str = ltrim( obj.get("sound") );
24
45
        sint8 sound_id=NO_SOUND;
25
 
        if (sound_str.size() > 0) {
 
46
        if (!sound_str.empty()) {
26
47
                // ok, there is some sound
27
48
                sound_id = atoi(sound_str.c_str());
28
49
                if (sound_id == 0 && sound_str[0] == '0') {
32
53
                        // old style id
33
54
                        sound_str = "";
34
55
                }
35
 
                if (sound_str.size() > 0) {
 
56
                if (!sound_str.empty()) {
36
57
                        sound_id = LOAD_SOUND;
37
58
                        total_len += sound_str.size() + 1;
38
59
                }
81
102
        node.write_uint8(fp, sound_id, 16);
82
103
        uint8 index = 17;
83
104
 
84
 
        if(sound_str.size() > 0) {
 
105
        if (!sound_str.empty()) {
85
106
                sint8 sv8 = sound_str.size();
86
107
                node.write_data_at(fp, &sv8, 17, sizeof(sint8));
87
108
                node.write_data_at(fp, sound_str.c_str(), 18, sound_str.size());
109
130
        slist_tpl<string> front_closekeys_ns;
110
131
        slist_tpl<string> front_closekeys_ew;
111
132
 
112
 
        string str;
113
 
 
114
133
        // open crossings ...
115
 
        for(int i=0;  1;  i++  ) {
116
 
                char buf[40];
117
 
 
118
 
                sprintf(buf, "openimage[ns][%i]", i);
119
 
                str = obj.get(buf);
120
 
                if (str.size() <= 0) {
121
 
                        break;
122
 
                }
123
 
                // ok, we have this direction
124
 
                openkeys_ns.append(str);
125
 
        }
126
 
        for(int i=0;  1;  i++  ) {
127
 
                char buf[40];
128
 
 
129
 
                sprintf(buf, "openimage[ew][%i]", i);
130
 
                str = obj.get(buf);
131
 
                if (str.size() <= 0) {
132
 
                        break;
133
 
                }
134
 
                // ok, we have this direction
135
 
                openkeys_ew.append(str);
136
 
        }
137
 
        if(openkeys_ns.get_count()==0  ||  openkeys_ew.get_count()==0) {
 
134
        make_list(obj, openkeys_ns, "openimage[ns]");
 
135
        make_list(obj, openkeys_ew, "openimage[ew]");
 
136
        // these must exists!
 
137
        if (openkeys_ns.empty() || openkeys_ew.empty()) {
138
138
                printf("*** FATAL ***:\nMissing images (at least one openimage! (but %i and %i found)!)\n", openkeys_ns.get_count(), openkeys_ew.get_count());
139
139
                exit(0);
140
140
        }
141
 
        // these must exists!
142
 
        imagelist_writer_t::instance()->write_obj(fp, node, openkeys_ns);
143
 
        imagelist_writer_t::instance()->write_obj(fp, node, openkeys_ew);
 
141
        write_list(fp, node, openkeys_ns);
 
142
        write_list(fp, node, openkeys_ew);
144
143
 
145
144
        // foreground
146
 
        for(int i=0;  1;  i++  ) {
147
 
                char buf[40];
148
 
 
149
 
                sprintf(buf, "front_openimage[ns][%i]", i);
150
 
                str = obj.get(buf);
151
 
                if (str.size() <= 0) {
152
 
                        break;
153
 
                }
154
 
                // ok, we have this direction
155
 
                front_openkeys_ns.append(str);
156
 
        }
157
 
        for(int i=0;  1;  i++  ) {
158
 
                char buf[40];
159
 
 
160
 
                sprintf(buf, "front_openimage[ew][%i]", i);
161
 
                str = obj.get(buf);
162
 
                if (str.size() <= 0) {
163
 
                        break;
164
 
                }
165
 
                // ok, we have this direction
166
 
                front_openkeys_ew.append(str);
167
 
        }
 
145
        make_list(obj, front_openkeys_ns, "front_openimage[ns]");
 
146
        make_list(obj, front_openkeys_ew, "front_openimage[ew]");
168
147
        // the following lists are optional
169
 
        if(front_openkeys_ns.get_count()>0) {
170
 
                imagelist_writer_t::instance()->write_obj(fp, node, front_openkeys_ns);
171
 
        }
172
 
        else {
173
 
                // really empty list ...
174
 
                xref_writer_t::instance()->write_obj(fp, node, obj_imagelist, "", false);
175
 
        }
176
 
        if(front_openkeys_ew.get_count()>0) {
177
 
                imagelist_writer_t::instance()->write_obj(fp, node, front_openkeys_ew);
178
 
        }
179
 
        else {
180
 
                // really empty list ...
181
 
                xref_writer_t::instance()->write_obj(fp, node, obj_imagelist, "", false);
182
 
        }
 
148
        write_list(fp, node, front_openkeys_ns);
 
149
        write_list(fp, node, front_openkeys_ew);
183
150
 
184
151
        // closed crossings ...
185
 
        for(int i=0;  1;  i++  ) {
186
 
                char buf[40];
187
 
 
188
 
                sprintf(buf, "closedimage[ns][%i]", i);
189
 
                str = obj.get(buf);
190
 
                if (str.size() <= 0) {
191
 
                        break;
192
 
                }
193
 
                // ok, we have this direction
194
 
                closekeys_ns.append(str);
195
 
        }
196
 
        for(int i=0;  1;  i++  ) {
197
 
                char buf[40];
198
 
 
199
 
                sprintf(buf, "closedimage[ew][%i]", i);
200
 
                str = obj.get(buf);
201
 
                if (str.size() <= 0) {
202
 
                        break;
203
 
                }
204
 
                // ok, we have this direction
205
 
                closekeys_ew.append(str);
206
 
        }
207
 
        if(closekeys_ns.get_count()>0) {
208
 
                imagelist_writer_t::instance()->write_obj(fp, node, closekeys_ns);
209
 
        }
210
 
        else {
211
 
                // really empty list ...
212
 
                xref_writer_t::instance()->write_obj(fp, node, obj_imagelist, "", false);
213
 
        }
214
 
        if(closekeys_ew.get_count()>0) {
215
 
                imagelist_writer_t::instance()->write_obj(fp, node, closekeys_ew);
216
 
        }
217
 
        else {
218
 
                // really empty list ...
219
 
                xref_writer_t::instance()->write_obj(fp, node, obj_imagelist, "", false);
220
 
        }
 
152
        make_list(obj, closekeys_ns, "closedimage[ns]");
 
153
        make_list(obj, closekeys_ew, "closedimage[ew]");
 
154
        write_list(fp, node, closekeys_ns);
 
155
        write_list(fp, node, closekeys_ew);
221
156
 
222
157
        // foreground
223
 
        for(int i=0;  1;  i++  ) {
224
 
                char buf[40];
225
 
 
226
 
                sprintf(buf, "front_closedimage[ns][%i]", i);
227
 
                str = obj.get(buf);
228
 
                if (str.size() <= 0) {
229
 
                        break;
230
 
                }
231
 
                // ok, we have this direction
232
 
                front_closekeys_ns.append(str);
233
 
        }
234
 
        for(int i=0;  1;  i++  ) {
235
 
                char buf[40];
236
 
 
237
 
                sprintf(buf, "front_closedimage[ew][%i]", i);
238
 
                str = obj.get(buf);
239
 
                if (str.size() <= 0) {
240
 
                        break;
241
 
                }
242
 
                // ok, we have this direction
243
 
                front_closekeys_ew.append(str);
244
 
        }
245
 
        if(front_closekeys_ns.get_count()>0) {
246
 
                imagelist_writer_t::instance()->write_obj(fp, node, front_closekeys_ns);
247
 
        }
248
 
        else {
249
 
                // really empty list ...
250
 
                xref_writer_t::instance()->write_obj(fp, node, obj_imagelist, "", false);
251
 
        }
252
 
        if(front_closekeys_ew.get_count()>0) {
253
 
                imagelist_writer_t::instance()->write_obj(fp, node, front_closekeys_ew);
254
 
        }
255
 
        else {
256
 
                // really empty list ...
257
 
                xref_writer_t::instance()->write_obj(fp, node, obj_imagelist, "", false);
258
 
        }
 
158
        make_list(obj, front_closekeys_ns, "front_closedimage[ns]");
 
159
        make_list(obj, front_closekeys_ew, "front_closedimage[ew]");
 
160
        write_list(fp, node, front_closekeys_ns);
 
161
        write_list(fp, node, front_closekeys_ew);
259
162
 
260
163
        node.write(fp);
261
164
}