← Back to branch summary

~ubuntu-branches/ubuntu/precise/widelands/precise-backports

« back to all changes in this revision

Viewing changes to src/widelands_map_bobdata_data_packet.cc

  • Committer: Bazaar Package Importer
  • Author(s): Martin Quinson
  • Date: 2005-02-14 10:41:12 UTC
  • Revision ID: james.westby@ubuntu.com-20050214104112-6v08iux9fptxpva9
Tags: upstream-build9
Import upstream version build9

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/widelands_map_bobdata_data_packet.cc
 
1
 
 
2
/*
 
3
 * Copyright (C) 2002-4 by the Widelands Development Team
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU General Public License
 
7
 * as published by the Free Software Foundation; either version 2
 
8
 * of the License, or (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
18
 *
 
19
 */
 
20
 
 
21
#include "bob.h"
 
22
#include "critter_bob.h"
 
23
#include "critter_bob_program.h"
 
24
#include "filesystem.h"
 
25
#include "game.h"
 
26
#include "map.h"
 
27
#include "player.h"
 
28
#include "soldier.h"
 
29
#include "transport.h"
 
30
#include "tribe.h"
 
31
#include "widelands_map_data_packet_ids.h"
 
32
#include "widelands_map_bobdata_data_packet.h"
 
33
#include "worker.h"
 
34
#include "worker_program.h"
 
35
#include "error.h"
 
36
 
 
37
#define CURRENT_PACKET_VERSION 1
 
38
 
 
39
// Bob subtype versions
 
40
#define CRITTER_BOB_PACKET_VERSION 1
 
41
#define WORKER_BOB_PACKET_VERSION 1
 
42
 
 
43
// Worker subtype versions
 
44
#define SOLDIER_WORKER_BOB_PACKET_VERSION 2
 
45
#define CARRIER_WORKER_BOB_PACKET_VERSION 1
 
46
 
 
47
/*
 
48
 * Destructor
 
49
 */
 
50
Widelands_Map_Bobdata_Data_Packet::~Widelands_Map_Bobdata_Data_Packet(void) {
 
51
}
 
52
 
 
53
/*
 
54
 * Read Function
 
55
 */
 
56
void Widelands_Map_Bobdata_Data_Packet::Read(FileRead* fr, Editor_Game_Base* egbase, bool skip, Widelands_Map_Map_Object_Loader* ol) throw(wexception) {
 
57
 
 
58
   // First packet version
 
59
   int packet_version=fr->Unsigned16();
 
60
 
 
61
   if(packet_version==CURRENT_PACKET_VERSION) {
 
62
      // Now the rest data len
 
63
      uint len = fr->Unsigned32();
 
64
      if(skip) {
 
65
         // Skip the rest, flags are not our problem here
 
66
         fr->Data(len);
 
67
         return;
 
68
      }
 
69
 
 
70
 
 
71
      while(1) {
 
72
         uint reg=fr->Unsigned32();
 
73
         if(reg==0xffffffff) break; // No more bobs
 
74
 
 
75
         assert(ol->is_object_known(reg));
 
76
         Bob* bob=static_cast<Bob*>(ol->get_object_by_file_index(reg));
 
77
 
 
78
         uchar read_owner=fr->Unsigned8();
 
79
         Player* plr_owner=0;
 
80
         if(read_owner) { 
 
81
            plr_owner=egbase->get_safe_player(read_owner);
 
82
            assert(plr_owner); // He must be there
 
83
         }
 
84
         
 
85
         Coords pos;
 
86
         pos.x=fr->Unsigned16();
 
87
         pos.y=fr->Unsigned16();
 
88
 
 
89
         // Basic initialisation
 
90
         bob->set_owner(plr_owner);
 
91
         bob->set_position(egbase, pos);
 
92
 
 
93
         // Look if we had an transfer
 
94
         bool have_transfer=fr->Unsigned8();
 
95
 
 
96
         Transfer* trans=0;
 
97
         if(have_transfer) {
 
98
            trans=bob->m_stack[0].transfer;
 
99
            assert(trans);
 
100
         }
 
101
 
 
102
         /*         if(!have_transfer)
 
103
                    bob->reset_tasks(static_cast<Game*>(egbase));
 
104
                    */
 
105
         bob->m_actid=fr->Unsigned32();
 
106
 
 
107
         // Animation
 
108
         if(fr->Unsigned8()) { 
 
109
            bob->m_anim=bob->get_descr()->get_animation(fr->CString());
 
110
         } else 
 
111
            bob->m_anim=0;
 
112
         bob->m_animstart=fr->Signed32();
 
113
 
 
114
         // walking 
 
115
         bob->m_walking=(Map_Object::WalkingDir)fr->Signed32();
 
116
         bob->m_walkstart=fr->Signed32();
 
117
         bob->m_walkend=fr->Signed32();
 
118
 
 
119
         uint oldstacksize=bob->m_stack.size();
 
120
         bob->m_stack.resize(fr->Unsigned16());
 
121
         for(uint i=0; i<bob->m_stack.size(); i++) {
 
122
            Bob::State* s=&bob->m_stack[i];
 
123
            Bob::Task* task;
 
124
 
 
125
            // Task
 
126
            std::string taskname=fr->CString();
 
127
            if(taskname=="idle") task=&Bob::taskIdle; 
 
128
            else if(taskname=="movepath") task=&Bob::taskMovepath;  
 
129
            else if(taskname=="forcemove") task=&Bob::taskForcemove; 
 
130
            else if(taskname=="roam") task=&Critter_Bob::taskRoam; 
 
131
            else if(taskname=="program") {
 
132
               if(bob->get_bob_type()==Bob::WORKER) 
 
133
                  task=&Worker::taskProgram; 
 
134
               else
 
135
                  task=&Critter_Bob::taskProgram; 
 
136
            } else if(taskname=="transfer") task=&Worker::taskTransfer; 
 
137
            else if(taskname=="buildingwork") task=&Worker::taskBuildingwork; 
 
138
            else if(taskname=="return") task=&Worker::taskReturn; 
 
139
            else if(taskname=="gowarehouse") task=&Worker::taskGowarehouse; 
 
140
            else if(taskname=="dropoff") task=&Worker::taskDropoff; 
 
141
            else if(taskname=="fetchfromflag") task=&Worker::taskFetchfromflag; 
 
142
            else if(taskname=="waitforcapacity") task=&Worker::taskWaitforcapacity; 
 
143
            else if(taskname=="leavebuilding") task=&Worker::taskLeavebuilding; 
 
144
            else if(taskname=="fugitive") task=&Worker::taskFugitive; 
 
145
            else if(taskname=="geologist") task=&Worker::taskGeologist; 
 
146
            else if(taskname=="road") task=&Carrier::taskRoad; 
 
147
            else if(taskname=="transport") task=&Carrier::taskTransport;
 
148
            else if(taskname=="launchattack") task=&Soldier::taskLaunchAttack; 
 
149
            else if(taskname=="defendbuilding") task=&Soldier::taskDefendBuilding; 
 
150
            else if(taskname=="waitforassault") task=&Soldier::taskWaitForAssault; 
 
151
            else if(taskname=="") continue; // Skip task
 
152
            else 
 
153
               throw wexception("Unknown task %s in file!\n", taskname.c_str());
 
154
 
 
155
            s->task=task;
 
156
 
 
157
            s->ivar1=fr->Signed32();
 
158
            s->ivar2=fr->Signed32();
 
159
            s->ivar3=fr->Signed32();
 
160
 
 
161
            s->transfer=0;
 
162
 
 
163
            int obj=fr->Unsigned32();
 
164
            if(obj) {
 
165
               assert(ol->is_object_known(obj));
 
166
               s->objvar1=ol->get_object_by_file_index(obj);
 
167
            } else
 
168
               s->objvar1=0;
 
169
            s->svar1=fr->CString();
 
170
            s->coords.x=fr->Signed32();
 
171
            s->coords.y=fr->Signed32();
 
172
 
 
173
            bool diranims=fr->Unsigned8();
 
174
            if(diranims) {
 
175
               s->diranims=new DirAnimations();
 
176
               s->diranims->overwrite_animation(1, bob->get_descr()->get_animation(fr->CString()));
 
177
               s->diranims->overwrite_animation(2, bob->get_descr()->get_animation(fr->CString()));
 
178
               s->diranims->overwrite_animation(3, bob->get_descr()->get_animation(fr->CString()));
 
179
               s->diranims->overwrite_animation(4, bob->get_descr()->get_animation(fr->CString()));
 
180
               s->diranims->overwrite_animation(5, bob->get_descr()->get_animation(fr->CString()));
 
181
               s->diranims->overwrite_animation(6, bob->get_descr()->get_animation(fr->CString()));
 
182
            } else
 
183
               s->diranims=0;
 
184
 
 
185
            uint pathsteps=fr->Unsigned16();
 
186
            if(s->path && i<oldstacksize)
 
187
               delete s->path;
 
188
            if(pathsteps) {
 
189
               Coords start;
 
190
               start.x=fr->Unsigned16();
 
191
               start.y=fr->Unsigned16();
 
192
               Path* path=new Path(egbase->get_map(), start);
 
193
               for(uint i=0; i<pathsteps; i++)
 
194
                  path->append(fr->Unsigned8());
 
195
               s->path=path;
 
196
            } else
 
197
               s->path=0;
 
198
 
 
199
            if(s->transfer && i<oldstacksize && !trans)
 
200
               delete s->transfer;
 
201
 
 
202
            if(s->task==&Worker::taskGowarehouse || s->task==&Worker::taskTransfer) 
 
203
               s->transfer=trans;
 
204
            else
 
205
               s->transfer=0;
 
206
 
 
207
            bool route=fr->Unsigned8();
 
208
            if(s->route && i<oldstacksize)
 
209
               if(!route) 
 
210
                  delete s->route;
 
211
               else
 
212
                  s->route->clear();
 
213
 
 
214
            if(route) {
 
215
               Route* route;
 
216
               if(!s->route)
 
217
                  route=new Route();
 
218
               else 
 
219
                  route=s->route;
 
220
               route->m_totalcost=fr->Signed32();
 
221
               int nsteps=fr->Unsigned16();
 
222
               for(int i=0; i<nsteps; i++) {
 
223
                  int reg=fr->Unsigned32();
 
224
                  assert(ol->is_object_known(reg));
 
225
                  Flag* flag=static_cast<Flag*>(ol->get_object_by_file_index(reg));
 
226
                  route->m_route.push_back(flag);
 
227
               }
 
228
               s->route=route;
 
229
               route->verify(static_cast<Game*>(egbase));
 
230
            } else 
 
231
               s->route=0;
 
232
 
 
233
            // Now programm
 
234
            bool program=fr->Unsigned8();
 
235
            if(program) {
 
236
               std::string progname=fr->CString();
 
237
               if(bob->get_bob_type()==Bob::WORKER) 
 
238
                  s->program=static_cast<Worker*>(bob)->get_descr()->get_program(progname);
 
239
               else
 
240
                  s->program=static_cast<Critter_Bob*>(bob)->get_descr()->get_program(progname);
 
241
            } else 
 
242
               s->program=0;
 
243
         }
 
244
 
 
245
         // Rest of bob stuff
 
246
         bob->m_stack_dirty=fr->Unsigned8();
 
247
         bob->m_sched_init_task=fr->Unsigned8();
 
248
         bob->m_signal=fr->CString();
 
249
 
 
250
         switch(bob->get_bob_type()) {
 
251
            case Bob::CRITTER: read_critter_bob(fr,egbase,ol,static_cast<Critter_Bob*>(bob)); break;
 
252
            case Bob::WORKER: read_worker_bob(fr,egbase,ol,static_cast<Worker*>(bob)); break;
 
253
            default: throw wexception("Unknown sub bob type %i in Widelands_Map_Bobdata_Data_Packet::Read\n", bob->get_bob_type());
 
254
         }
 
255
 
 
256
         ol->mark_object_as_loaded(bob);
 
257
      }
 
258
      // DONE
 
259
      return;
 
260
   }
 
261
   throw wexception("Unknown version %i in Widelands_Map_Bobdata_Data_Packet!\n", packet_version);
 
262
}
 
263
 
 
264
void Widelands_Map_Bobdata_Data_Packet::read_critter_bob(FileRead* fr, Editor_Game_Base*, Widelands_Map_Map_Object_Loader*, Critter_Bob*) {
 
265
   int version=fr->Unsigned16();
 
266
 
 
267
   if(version==CRITTER_BOB_PACKET_VERSION) {
 
268
      // No data for critter bob currently
 
269
   } else 
 
270
      throw wexception("Unknown version %i in Critter Bob Subpacket!\n", version); 
 
271
}
 
272
 
 
273
void Widelands_Map_Bobdata_Data_Packet::read_worker_bob(FileRead* fr, Editor_Game_Base* egbase, Widelands_Map_Map_Object_Loader* ol, Worker* worker) {
 
274
   int version=fr->Unsigned16();
 
275
 
 
276
   if(version==WORKER_BOB_PACKET_VERSION) {
 
277
      switch(worker->get_worker_type()) {
 
278
         case Worker_Descr::NORMAL: break;
 
279
         case Worker_Descr::SOLDIER: 
 
280
         {
 
281
            int soldierversion=fr->Unsigned16();
 
282
            if(soldierversion==SOLDIER_WORKER_BOB_PACKET_VERSION) {
 
283
               Soldier* soldier=static_cast<Soldier*>(worker);
 
284
 
 
285
               soldier->m_hp_current=fr->Unsigned32();
 
286
               soldier->m_hp_max=fr->Unsigned32();
 
287
               soldier->m_min_attack=fr->Unsigned32();
 
288
               soldier->m_max_attack=fr->Unsigned32();
 
289
               soldier->m_defense=fr->Unsigned32();
 
290
               soldier->m_evade=fr->Unsigned32();
 
291
               soldier->m_hp_level=fr->Unsigned32();
 
292
               soldier->m_attack_level=fr->Unsigned32();
 
293
               soldier->m_defense_level=fr->Unsigned32();
 
294
               soldier->m_evade_level=fr->Unsigned32();
 
295
               soldier->m_marked=fr->Unsigned8();
 
296
            } else
 
297
               throw wexception("Unknown version %i in Soldier Bob (SubSubPacket)!", soldierversion);
 
298
         }
 
299
         break;
 
300
 
 
301
         case Worker_Descr::CARRIER:
 
302
         {
 
303
            int carrierversion=fr->Unsigned16();
 
304
            if(carrierversion==CARRIER_WORKER_BOB_PACKET_VERSION) {
 
305
               Carrier* c=static_cast<Carrier*>(worker);
 
306
               c->m_acked_ware=fr->Signed32();         
 
307
            }
 
308
         }
 
309
         break;
 
310
         default: throw wexception("Unknown Worker %i in Widelands_Map_Bobdata_Data_Packet::read_worker_bob()\n", worker->get_worker_type());
 
311
      } 
 
312
 
 
313
      // location
 
314
      uint reg=fr->Unsigned32();
 
315
      if(reg) {
 
316
         assert(ol->is_object_known(reg));
 
317
         worker->set_location(static_cast<PlayerImmovable*>(ol->get_object_by_file_index(reg)));
 
318
         assert(worker->m_location.get(egbase));
 
319
      } else
 
320
         worker->m_location=0;
 
321
 
 
322
      
 
323
      // Carried item
 
324
      reg=fr->Unsigned32();
 
325
      if(reg) {
 
326
         assert(ol->is_object_known(reg));
 
327
         worker->m_carried_item=ol->get_object_by_file_index(reg);
 
328
      } else
 
329
         worker->m_carried_item=0;
 
330
 
 
331
      // Skip supply
 
332
 
 
333
      worker->m_needed_exp=fr->Signed32();
 
334
      worker->m_current_exp=fr->Signed32();
 
335
 
 
336
      Economy* eco=0;
 
337
      if(worker->m_location.get(egbase)) 
 
338
         eco=static_cast<PlayerImmovable*>(worker->m_location.get(egbase))->get_economy();
 
339
      
 
340
      worker->set_economy(eco);
 
341
      if(worker->m_carried_item.get(egbase))
 
342
         static_cast<WareInstance*>(worker->m_carried_item.get(egbase))->set_economy(eco);
 
343
 
 
344
 
 
345
   } else 
 
346
      throw wexception("Unknown version %i in Worker Bob Subpacket!\n", version); 
 
347
 
 
348
}
 
349
 
 
350
/*
 
351
 * Write Function
 
352
 */
 
353
void Widelands_Map_Bobdata_Data_Packet::Write(FileWrite* fw, Editor_Game_Base* egbase, Widelands_Map_Map_Object_Saver* os) throw(wexception) {
 
354
   // first of all the magic bytes
 
355
   fw->Unsigned16(PACKET_BOBDATA);
 
356
 
 
357
   // now packet version
 
358
   fw->Unsigned16(CURRENT_PACKET_VERSION);
 
359
 
 
360
   // Here we will insert skip data (packet lenght) 
 
361
   // later, write a dummy for know
 
362
   int filepos = fw->GetFilePos();
 
363
   fw->Unsigned32(0x00000000);
 
364
   fw->ResetByteCounter();
 
365
  
 
366
   Map* map=egbase->get_map();
 
367
   for(ushort y=0; y<map->get_height(); y++) {
 
368
      for(ushort x=0; x<map->get_width(); x++) {
 
369
 
 
370
         std::vector<Bob*> bobarr;
 
371
 
 
372
         egbase->get_map()->find_bobs(Coords(x,y), 0, &bobarr);
 
373
 
 
374
         for(uint i=0; i<bobarr.size(); i++) {
 
375
            Bob* ibob=bobarr[i];
 
376
            for(uint j=i; j<bobarr.size(); j++) {
 
377
               Bob* jbob=bobarr[j];
 
378
               if(ibob->get_file_serial() < jbob->get_file_serial()) {
 
379
                  bobarr[i] = jbob;
 
380
                  bobarr[j] = ibob;
 
381
                  ibob=jbob;
 
382
               } 
 
383
            }
 
384
         }
 
385
 
 
386
         for(uint i=0; i<bobarr.size(); i++) {
 
387
            Bob* bob=bobarr[i];
 
388
            assert(os->is_object_known(bob));
 
389
            uint reg=os->get_object_file_index(bob);
 
390
 
 
391
            fw->Unsigned32(reg);
 
392
            // BOB STUFF
 
393
 
 
394
            if(bob->m_owner) 
 
395
               fw->Unsigned8(bob->m_owner->get_player_number());
 
396
            else 
 
397
               fw->Unsigned8(0);
 
398
 
 
399
            // m_position
 
400
            fw->Unsigned16(bob->m_position.x);
 
401
            fw->Unsigned16(bob->m_position.y);
 
402
            // FIELD can't be saved
 
403
 
 
404
            // m_linknext, linkpprev are handled automatically
 
405
 
 
406
            // Are we currently transfering?
 
407
            if(bob->m_stack.size() && bob->m_stack[0].transfer) 
 
408
               fw->Unsigned8(1);
 
409
            else
 
410
               fw->Unsigned8(0);
 
411
 
 
412
            fw->Unsigned32(bob->m_actid);
 
413
 
 
414
            // Animation
 
415
            if(bob->m_anim) {
 
416
               fw->Unsigned8(1);
 
417
               fw->CString(bob->get_descr()->get_animation_name(bob->m_anim).c_str());
 
418
            } else 
 
419
               fw->Unsigned8(0);
 
420
            fw->Signed32(bob->m_animstart);
 
421
 
 
422
            // WalkingDirection
 
423
            fw->Signed32(bob->m_walking);
 
424
 
 
425
            // WalkingStart
 
426
            fw->Signed32(bob->m_walkstart);
 
427
 
 
428
            // WalkEnd
 
429
            fw->Signed32(bob->m_walkend);
 
430
 
 
431
            // Nr of States
 
432
            fw->Unsigned16(bob->m_stack.size());
 
433
            for(uint i=0; i<bob->m_stack.size(); i++) {
 
434
               Bob::State* s=&bob->m_stack[i];
 
435
 
 
436
               // Write name, enough to reconstruct the
 
437
               // Task structure
 
438
               fw->CString(s->task->name);
 
439
 
 
440
               fw->Signed32(s->ivar1);
 
441
               fw->Signed32(s->ivar2);
 
442
               fw->Signed32(s->ivar3);
 
443
 
 
444
               Map_Object* obj=s->objvar1.get(egbase);
 
445
               if(obj) {
 
446
                  assert(os->is_object_known(obj));
 
447
                  fw->Unsigned32(os->get_object_file_index(obj));
 
448
               } else 
 
449
                  fw->Unsigned32(0);
 
450
 
 
451
               fw->CString(s->svar1.c_str());
 
452
 
 
453
               // Coords
 
454
               fw->Signed32(s->coords.x);
 
455
               fw->Signed32(s->coords.y);
 
456
 
 
457
               if(s->diranims) {
 
458
                  fw->Unsigned8(1);
 
459
                  fw->CString(bob->get_descr()->get_animation_name(s->diranims->get_animation(1)).c_str());
 
460
                  fw->CString(bob->get_descr()->get_animation_name(s->diranims->get_animation(2)).c_str());
 
461
                  fw->CString(bob->get_descr()->get_animation_name(s->diranims->get_animation(3)).c_str());
 
462
                  fw->CString(bob->get_descr()->get_animation_name(s->diranims->get_animation(4)).c_str());
 
463
                  fw->CString(bob->get_descr()->get_animation_name(s->diranims->get_animation(5)).c_str());
 
464
                  fw->CString(bob->get_descr()->get_animation_name(s->diranims->get_animation(6)).c_str());
 
465
               } else 
 
466
                  fw->Unsigned8(0);
 
467
 
 
468
               // Path
 
469
               if(s->path) {
 
470
                  fw->Unsigned16(s->path->get_nsteps());
 
471
                  Coords pstart=s->path->get_start();
 
472
                  fw->Unsigned16(pstart.x);
 
473
                  fw->Unsigned16(pstart.y);
 
474
                  for(int i=0; i<s->path->get_nsteps(); i++) 
 
475
                     fw->Unsigned8(s->path->get_step(i));
 
476
               } else
 
477
                  fw->Unsigned16(0);
 
478
 
 
479
               // Route
 
480
               if(s->route) {
 
481
                  fw->Unsigned8(1);
 
482
                  fw->Signed32(s->route->get_totalcost());
 
483
                  fw->Unsigned16(s->route->get_nrsteps());
 
484
                  for(int i=0; i<s->route->get_nrsteps(); i++) {
 
485
                     Flag* f=s->route->get_flag(egbase, i);
 
486
                     assert(os->is_object_known(f));
 
487
                     fw->Unsigned32(os->get_object_file_index(f));
 
488
                  }
 
489
               } else 
 
490
                  fw->Unsigned8(0);
 
491
 
 
492
               // Programm
 
493
               if(s->program) {
 
494
                  fw->Unsigned8(1);
 
495
                  fw->CString(s->program->get_name().c_str());
 
496
               } else 
 
497
                  fw->Unsigned8(0);
 
498
 
 
499
 
 
500
            }
 
501
 
 
502
            fw->Unsigned8(bob->m_stack_dirty);
 
503
            fw->Unsigned8(bob->m_sched_init_task);
 
504
            fw->CString(bob->m_signal.c_str());
 
505
 
 
506
            switch(bob->get_bob_type()) {
 
507
               case Bob::CRITTER: write_critter_bob(fw,egbase,os,static_cast<Critter_Bob*>(bob)); break;
 
508
               case Bob::WORKER: write_worker_bob(fw,egbase,os,static_cast<Worker*>(bob)); break;
 
509
               default: throw wexception("Unknown sub bob type %i in Widelands_Map_Bobdata_Data_Packet::Write\n", bob->get_bob_type());
 
510
 
 
511
            }
 
512
 
 
513
            os->mark_object_as_saved(bob);
 
514
         }
 
515
 
 
516
      }
 
517
   }
 
518
   fw->Unsigned32(0xffffffff); // No more bobs
 
519
 
 
520
   // Now, write the packet length
 
521
   fw->Unsigned32(fw->GetByteCounter(), filepos);
 
522
   
 
523
   // DONE
 
524
}
 
525
 
 
526
void Widelands_Map_Bobdata_Data_Packet::write_critter_bob(FileWrite* fw, Editor_Game_Base* egbase, Widelands_Map_Map_Object_Saver* os, Critter_Bob* critter) {
 
527
   fw->Unsigned16(CRITTER_BOB_PACKET_VERSION);
 
528
}
 
529
 
 
530
void Widelands_Map_Bobdata_Data_Packet::write_worker_bob(FileWrite* fw, Editor_Game_Base* egbase, Widelands_Map_Map_Object_Saver* os, Worker* worker) {
 
531
   fw->Unsigned16(WORKER_BOB_PACKET_VERSION);
 
532
 
 
533
   switch(worker->get_worker_type()) {
 
534
      case Worker_Descr::NORMAL: break; 
 
535
      case Worker_Descr::SOLDIER:
 
536
      {
 
537
         fw->Unsigned16(SOLDIER_WORKER_BOB_PACKET_VERSION);
 
538
         Soldier* soldier=static_cast<Soldier*>(worker);
 
539
 
 
540
         fw->Unsigned32(soldier->m_hp_current);
 
541
         fw->Unsigned32(soldier->m_hp_max);
 
542
         fw->Unsigned32(soldier->m_min_attack);
 
543
         fw->Unsigned32(soldier->m_max_attack);
 
544
         fw->Unsigned32(soldier->m_defense);
 
545
         fw->Unsigned32(soldier->m_evade);
 
546
         fw->Unsigned32(soldier->m_hp_level);
 
547
         fw->Unsigned32(soldier->m_attack_level);
 
548
         fw->Unsigned32(soldier->m_defense_level);
 
549
         fw->Unsigned32(soldier->m_evade_level);
 
550
         fw->Unsigned8 (soldier->m_marked);
 
551
      }
 
552
      break;
 
553
 
 
554
      case Worker_Descr::CARRIER:
 
555
      {
 
556
         fw->Unsigned16(CARRIER_WORKER_BOB_PACKET_VERSION);
 
557
         Carrier* c=static_cast<Carrier*>(worker);
 
558
 
 
559
         fw->Signed32(c->m_acked_ware);
 
560
      }
 
561
      break;
 
562
      default: throw wexception("Unknown Worker %i in Widelands_Map_Bobdata_Data_Packet::write_worker_bob()\n", worker->get_worker_type());
 
563
   }                     
 
564
 
 
565
   // location
 
566
   Map_Object* loca=worker->m_location.get(egbase);
 
567
   if(loca) {
 
568
      assert(os->is_object_known(loca));
 
569
      fw->Unsigned32(os->get_object_file_index(loca));
 
570
   } else 
 
571
      fw->Unsigned32(0);
 
572
 
 
573
   // Economy is not our beer
 
574
 
 
575
   // Carried item
 
576
   Map_Object* carried_item=worker->m_carried_item.get(egbase);
 
577
   if(carried_item) {
 
578
      assert(os->is_object_known(carried_item));
 
579
      fw->Unsigned32(os->get_object_file_index(carried_item));
 
580
   } else
 
581
      fw->Unsigned32(0);
 
582
 
 
583
   /*This is not needed
 
584
    * Write if a idle supply is to be created
 
585
   if(worker->m_supply) 
 
586
      fw->Unsigned8(1);
 
587
   else
 
588
      fw->Unsigned8(0);
 
589
      */
 
590
 
 
591
   fw->Signed32(worker->m_needed_exp);
 
592
   fw->Signed32(worker->m_current_exp);
 
593
}