← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/widelands_map_roaddata_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_roaddata_data_packet.cc
 
1
/*
 
2
 * Copyright (C) 2002-4 by the Widelands Development Team
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU General Public License
 
6
 * as published by the Free Software Foundation; either version 2
 
7
 * of the License, or (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
17
 *
 
18
 */
 
19
 
 
20
#include <map>
 
21
#include "editor.h"
 
22
#include "editorinteractive.h"
 
23
#include "editor_game_base.h"
 
24
#include "filesystem.h"
 
25
#include "game.h"
 
26
#include "map.h"
 
27
#include "player.h"
 
28
#include "transport.h"
 
29
#include "tribe.h"
 
30
#include "widelands_map_data_packet_ids.h"
 
31
#include "widelands_map_roaddata_data_packet.h"
 
32
#include "error.h"
 
33
 
 
34
#define CURRENT_PACKET_VERSION 1
 
35
 
 
36
/*
 
37
 * Destructor
 
38
 */
 
39
Widelands_Map_Roaddata_Data_Packet::~Widelands_Map_Roaddata_Data_Packet(void) {
 
40
}
 
41
 
 
42
/*
 
43
 * Read Function
 
44
 */
 
45
void Widelands_Map_Roaddata_Data_Packet::Read(FileRead* fr, Editor_Game_Base* egbase, bool skip, Widelands_Map_Map_Object_Loader* ol) throw(wexception) {
 
46
 
 
47
   // First packet version
 
48
   int packet_version=fr->Unsigned16();
 
49
 
 
50
   if(packet_version==CURRENT_PACKET_VERSION) {
 
51
      // Now the rest data len
 
52
      uint len = fr->Unsigned32();
 
53
      if(skip) {
 
54
         // Skip the rest, flags are not our problem here
 
55
         fr->Data(len);
 
56
         return;
 
57
      }
 
58
 
 
59
 
 
60
      while(1) {
 
61
         uint ser=fr->Unsigned32();
 
62
         if(ser==0xffffffff) // end of roaddata
 
63
            break;
 
64
         assert(ol->is_object_known(ser));
 
65
         assert(ol->get_object_by_file_index(ser)->get_type()==Map_Object::ROAD);
 
66
 
 
67
         Road* r=static_cast<Road*>(ol->get_object_by_file_index(ser));
 
68
 
 
69
         assert(!ol->is_object_loaded(r));
 
70
 
 
71
         Player* plr = egbase->get_safe_player(fr->Unsigned8());
 
72
         assert(plr); 
 
73
         
 
74
         r->set_owner(plr);
 
75
         r->m_type=fr->Unsigned32();
 
76
         ser=fr->Unsigned32();
 
77
         uint ser1=fr->Unsigned32();
 
78
         assert(ol->is_object_known(ser));
 
79
         assert(ol->is_object_known(ser1));
 
80
         r->m_flags[0]=static_cast<Flag*>(ol->get_object_by_file_index(ser));
 
81
         r->m_flags[1]=static_cast<Flag*>(ol->get_object_by_file_index(ser1));
 
82
         r->m_flagidx[0]=fr->Unsigned32();
 
83
         r->m_flagidx[1]=fr->Unsigned32();
 
84
 
 
85
         r->m_cost[0]=fr->Unsigned32();
 
86
         r->m_cost[1]=fr->Unsigned32();
 
87
         int nsteps=fr->Unsigned16();
 
88
         assert(nsteps);
 
89
         Path p(egbase->get_map(), r->m_flags[0]->get_position());
 
90
         int i=0;
 
91
         for(i=0; i<nsteps; i++)
 
92
            p.append(fr->Unsigned8());
 
93
         r->set_path(egbase, p);
 
94
 
 
95
         // Now that all rudimentary data is set, init this road,
 
96
         // than overwrite the initialization values
 
97
         r->link_into_flags(egbase);
 
98
 
 
99
         r->m_idle_index=fr->Unsigned32();
 
100
         r->m_desire_carriers=fr->Unsigned32();
 
101
         assert(!r->m_carrier.get(egbase));
 
102
         uint carrierid=fr->Unsigned32();
 
103
         if(carrierid) {
 
104
            assert(ol->is_object_known(carrierid));
 
105
            r->m_carrier=ol->get_object_by_file_index(carrierid);
 
106
         } else 
 
107
            r->m_carrier=0;
 
108
 
 
109
         if(r->m_carrier_request) {
 
110
            delete r->m_carrier_request;
 
111
            r->m_carrier_request=0;
 
112
         } 
 
113
 
 
114
         bool request_exists=fr->Unsigned8();
 
115
         if(request_exists) {
 
116
            if(egbase->is_game()) {
 
117
               r->m_carrier_request = new Request(r, 0,
 
118
                     &Road::request_carrier_callback, r, Request::WORKER);
 
119
               r->m_carrier_request->Read(fr, egbase, ol);
 
120
            }
 
121
         } else {
 
122
            r->m_carrier_request=0;
 
123
         }
 
124
 
 
125
         log("Loaded roaddata for Road: %p\n", r);
 
126
 
 
127
         ol->mark_object_as_loaded(r);
 
128
      }
 
129
      // DONE
 
130
      return;
 
131
   }
 
132
   throw wexception("Unknown version %i in Widelands_Map_Roaddata_Data_Packet!\n", packet_version);
 
133
}
 
134
 
 
135
 
 
136
/*
 
137
 * Write Function
 
138
 */
 
139
void Widelands_Map_Roaddata_Data_Packet::Write(FileWrite* fw, Editor_Game_Base* egbase, Widelands_Map_Map_Object_Saver* os) throw(wexception) {
 
140
   // first of all the magic bytes
 
141
   fw->Unsigned16(PACKET_ROADDATA);
 
142
 
 
143
   // now packet version
 
144
   fw->Unsigned16(CURRENT_PACKET_VERSION);
 
145
 
 
146
   // Here we will insert skip data (packet lenght) 
 
147
   // later, write a dummy for know
 
148
   int filepos = fw->GetFilePos();
 
149
   fw->Unsigned32(0x00000000);
 
150
   fw->ResetByteCounter();
 
151
 
 
152
   // We walk the map again for roads
 
153
   Map* map=egbase->get_map();
 
154
   for(ushort y=0; y<map->get_height(); y++) {
 
155
      for(ushort x=0; x<map->get_width(); x++) {
 
156
         Field* f=map->get_field(Coords(x,y));
 
157
         BaseImmovable* imm=f->get_immovable();
 
158
         if(!imm) continue;
 
159
         
 
160
         if(imm->get_type()==Map_Object::ROAD) {
 
161
            Road* r=static_cast<Road*>(imm);
 
162
            assert(os->is_object_known(r));
 
163
            if(os->is_object_saved(r)) 
 
164
               continue;
 
165
            uint ser=os->get_object_file_index(r);
 
166
           
 
167
            // First, write serial
 
168
            fw->Unsigned32(ser);
 
169
            
 
170
            // First, write PlayerImmovable Stuff
 
171
            // Theres only the owner
 
172
            fw->Unsigned8(r->get_owner()->get_player_number());
 
173
 
 
174
            // type
 
175
            fw->Unsigned32(r->m_type);
 
176
 
 
177
            // Serial of flags
 
178
            assert(os->is_object_known(r->m_flags[0]));
 
179
            assert(os->is_object_known(r->m_flags[1]));
 
180
            fw->Unsigned32(os->get_object_file_index(r->m_flags[0]));
 
181
            fw->Unsigned32(os->get_object_file_index(r->m_flags[1]));
 
182
 
 
183
            // Flags index
 
184
            fw->Unsigned32(r->m_flagidx[0]);
 
185
            fw->Unsigned32(r->m_flagidx[1]);
 
186
 
 
187
            // Cost
 
188
            fw->Unsigned32(r->m_cost[0]);
 
189
            fw->Unsigned32(r->m_cost[1]);
 
190
 
 
191
            // Path
 
192
            fw->Unsigned16(r->m_path.get_nsteps());
 
193
            int i=0;
 
194
            for(i=0; i<r->m_path.get_nsteps(); i++) 
 
195
               fw->Unsigned8(r->m_path.get_step(i));
 
196
 
 
197
            // Idle index
 
198
            fw->Unsigned32(r->m_idle_index);
 
199
 
 
200
            // Desired carrier
 
201
            fw->Unsigned32(r->m_desire_carriers);
 
202
 
 
203
            // Carrier
 
204
            if(r->m_carrier.get(egbase)) {
 
205
               assert(os->is_object_known(r->m_carrier.get(egbase)));
 
206
               fw->Unsigned32(os->get_object_file_index(r->m_carrier.get(egbase)));
 
207
            } else { 
 
208
               fw->Unsigned32(0);
 
209
            }
 
210
 
 
211
            // Request 
 
212
            if(r->m_carrier_request) { 
 
213
               fw->Unsigned8(1);
 
214
               r->m_carrier_request->Write(fw, egbase, os);
 
215
            } else 
 
216
               fw->Unsigned8(0);
 
217
 
 
218
            os->mark_object_as_saved(r);
 
219
         }
 
220
      }
 
221
   }
 
222
  
 
223
   fw->Unsigned32(0xFFFFFFFF); // End of roads
 
224
 
 
225
   // Now, write the packet length
 
226
   fw->Unsigned32(fw->GetByteCounter(), filepos);
 
227
   // DONE
 
228
}