← Back to branch summary

~ubuntu-branches/debian/squeeze/simutrans/squeeze

« back to all changes in this revision

Viewing changes to dings/roadsign.cc

  • Committer: Bazaar Package Importer
  • Author(s): Ansgar Burchardt
  • Date: 2009-03-06 20:40:03 UTC
  • mfrom: (1.2.1 upstream) (6.2.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090306204003-tk31qp9fyr7cmv4g
Tags: 102.0-1
* New upstream release.
  + Refresh patches.
  + Update translations.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dings/roadsign.cc
11
11
#include "../simdebug.h"
12
12
#include "../simdings.h"
13
13
#include "../simimg.h"
14
 
#include "../simplay.h"
 
14
#include "../player/simplay.h"
15
15
#include "../simworld.h"
16
16
 
17
17
#include "../besch/roadsign_besch.h"
47
47
        rdwr(file);
48
48
        if(besch) {
49
49
                // if more than one state, we will switch direction and phase for traffic lights
50
 
                automatic = (besch->gib_bild_anzahl()>4  &&  besch->gib_wtyp()==road_wt);
 
50
                automatic = (besch->get_bild_anzahl()>4  &&  besch->get_wtyp()==road_wt);
51
51
        }
52
52
}
53
53
 
59
59
        this->dir = dir;
60
60
        bild = after_bild = IMG_LEER;
61
61
        zustand = 0;
62
 
        setze_besitzer( sp );
 
62
        set_besitzer( sp );
63
63
        // if more than one state, we will switch direction and phase for traffic lights
64
 
        automatic = (besch->gib_bild_anzahl()>4  &&  besch->gib_wtyp()==road_wt);
 
64
        automatic = (besch->get_bild_anzahl()>4  &&  besch->get_wtyp()==road_wt);
65
65
}
66
66
 
67
67
 
68
68
 
69
69
roadsign_t::~roadsign_t()
70
70
{
71
 
        const grund_t *gr = welt->lookup(gib_pos());
 
71
        const grund_t *gr = welt->lookup(get_pos());
72
72
        if(gr) {
73
 
                weg_t *weg = gr->gib_weg((waytype_t)besch->gib_wtyp());
 
73
                weg_t *weg = gr->get_weg((waytype_t)besch->get_wtyp());
74
74
                if(weg) {
75
75
                        // Weg wieder freigeben, wenn das Signal nicht mehr da ist.
76
 
                        weg->setze_ribi_maske(ribi_t::keine);
 
76
                        weg->set_ribi_maske(ribi_t::keine);
77
77
                }
78
78
                else {
79
79
                        dbg->error("roadsign_t::~roadsign_t()","roadsign_t %p was deleted but ground was not a road!");
89
89
void roadsign_t::set_dir(ribi_t::ribi dir)
90
90
{
91
91
        this->dir = dir;
92
 
        weg_t *weg = welt->lookup(gib_pos())->gib_weg((waytype_t)besch->gib_wtyp());
93
 
        if(besch->gib_wtyp()!=track_wt  &&   besch->gib_wtyp()!=monorail_wt) {
 
92
        weg_t *weg = welt->lookup(get_pos())->get_weg((waytype_t)besch->get_wtyp());
 
93
        if(besch->get_wtyp()!=track_wt  &&   besch->get_wtyp()!=monorail_wt&&   besch->get_wtyp()!=maglev_wt&&   besch->get_wtyp()!=narrowgauge_wt) {
94
94
                weg->count_sign();
95
95
        }
96
96
        if(besch->is_single_way()  ||  besch->is_signal()  ||  besch->is_pre_signal()  ||  besch->is_longblock_signal()) {
97
97
                // set mask, if it is a signle way ...
98
98
                weg->count_sign();
99
99
                if(ribi_t::ist_einfach(dir)) {
100
 
                        weg->setze_ribi_maske(dir);
 
100
                        weg->set_ribi_maske(dir);
101
101
                }
102
102
                else {
103
 
                        weg->setze_ribi_maske(ribi_t::keine);
 
103
                        weg->set_ribi_maske(ribi_t::keine);
104
104
                }
105
105
DBG_MESSAGE("roadsign_t::set_dir()","ribi %i",dir);
106
106
        }
107
107
 
108
108
        // force redraw
109
 
        mark_image_dirty(gib_bild(),0);
 
109
        mark_image_dirty(get_bild(),0);
110
110
        mark_image_dirty(after_bild,after_offset);
111
111
 
112
112
        bild = IMG_LEER;
127
127
        if(besch->is_single_way()) {
128
128
                buf.append(translator::translate("\nsingle way"));
129
129
        }
130
 
        if(besch->gib_min_speed()!=0) {
 
130
        if(besch->get_min_speed()!=0) {
131
131
                buf.append(translator::translate("\nminimum speed:"));
132
 
                buf.append(speed_to_kmh(besch->gib_min_speed()));
 
132
                buf.append(speed_to_kmh(besch->get_min_speed()));
133
133
        }
134
134
        buf.append(translator::translate("\ndirection:"));
135
135
        buf.append(dir);
146
146
        after_offset = 0;
147
147
 
148
148
        // vertical offset of the signal positions
149
 
        const grund_t *gr=welt->lookup(gib_pos());
 
149
        const grund_t *gr=welt->lookup(get_pos());
150
150
        if(gr==NULL) {
151
151
                return;
152
152
        }
153
153
 
154
 
        hang_t::typ hang = gr->gib_weg_hang();
 
154
        hang_t::typ hang = gr->get_weg_hang();
155
155
        if(hang==hang_t::flach) {
156
 
                setze_yoff( -gr->gib_weg_yoff() );
 
156
                set_yoff( -gr->get_weg_yoff() );
157
157
                after_offset = 0;
158
158
        }
159
159
        else {
164
164
                        }
165
165
                }
166
166
                if(hang==hang_t::ost ||  hang==hang_t::nord) {
167
 
                        setze_yoff( -TILE_HEIGHT_STEP );
 
167
                        set_yoff( -TILE_HEIGHT_STEP );
168
168
                        after_offset = +TILE_HEIGHT_STEP;
169
169
                }
170
170
                else {
171
 
                        setze_yoff( 0 );
 
171
                        set_yoff( 0 );
172
172
                        after_offset = -TILE_HEIGHT_STEP;
173
173
                }
174
174
        }
179
179
                after_bild = IMG_LEER;
180
180
 
181
181
                if(dir&ribi_t::ost) {
182
 
                        after_bild = besch->gib_bild_nr(3+zustand*4);
 
182
                        after_bild = besch->get_bild_nr(3+zustand*4);
183
183
                }
184
184
 
185
185
                if(dir&ribi_t::nord) {
186
186
                        if(after_bild!=IMG_LEER) {
187
 
                                tmp_bild = besch->gib_bild_nr(0+zustand*4);
 
187
                                tmp_bild = besch->get_bild_nr(0+zustand*4);
188
188
                        }
189
189
                        else {
190
 
                                after_bild = besch->gib_bild_nr(0+zustand*4);
 
190
                                after_bild = besch->get_bild_nr(0+zustand*4);
191
191
                        }
192
192
                }
193
193
 
194
194
                if(dir&ribi_t::west) {
195
 
                        tmp_bild = besch->gib_bild_nr(2+zustand*4);
 
195
                        tmp_bild = besch->get_bild_nr(2+zustand*4);
196
196
                }
197
197
 
198
198
                if(dir&ribi_t::sued) {
199
199
                        if(tmp_bild!=IMG_LEER) {
200
 
                                after_bild = besch->gib_bild_nr(1+zustand*4);
 
200
                                after_bild = besch->get_bild_nr(1+zustand*4);
201
201
                        }
202
202
                        else {
203
 
                                tmp_bild = besch->gib_bild_nr(1+zustand*4);
 
203
                                tmp_bild = besch->get_bild_nr(1+zustand*4);
204
204
                        }
205
205
                }
206
206
 
212
212
                        after_bild = IMG_LEER;
213
213
                }
214
214
 
215
 
                setze_bild( tmp_bild );
 
215
                set_bild( tmp_bild );
216
216
        }
217
217
        else {
218
218
                // traffic light
219
 
                weg_t *str=gr->gib_weg(road_wt);
 
219
                weg_t *str=gr->get_weg(road_wt);
220
220
                if(str) {
221
 
                        const uint8 weg_dir = str->gib_ribi_unmasked();
 
221
                        const uint8 weg_dir = str->get_ribi_unmasked();
222
222
                        const uint8 direction = (dir&ribi_t::nord)!=0;
223
223
 
224
224
                        // other front/back images for left side ...
227
227
                                // drive left
228
228
                                if(weg_dir&ribi_t::nord) {
229
229
                                        if(weg_dir&ribi_t::ost) {
230
 
                                                after_bild = besch->gib_bild_nr(6+direction*8);
 
230
                                                after_bild = besch->get_bild_nr(6+direction*8);
231
231
                                        }
232
232
                                        else {
233
 
                                                after_bild = besch->gib_bild_nr(1+direction*8);
 
233
                                                after_bild = besch->get_bild_nr(1+direction*8);
234
234
                                        }
235
235
                                }
236
236
                                else if(weg_dir&ribi_t::ost) {
237
 
                                        after_bild = besch->gib_bild_nr(2+direction*8);
 
237
                                        after_bild = besch->get_bild_nr(2+direction*8);
238
238
                                }
239
239
 
240
240
                                if(weg_dir&ribi_t::west) {
241
241
                                        if(weg_dir&ribi_t::sued) {
242
 
                                                setze_bild(besch->gib_bild_nr(7+direction*8));
 
242
                                                set_bild(besch->get_bild_nr(7+direction*8));
243
243
                                        }
244
244
                                        else {
245
 
                                                setze_bild(besch->gib_bild_nr(3+direction*8));
 
245
                                                set_bild(besch->get_bild_nr(3+direction*8));
246
246
                                        }
247
247
                                }
248
248
                                else if(weg_dir&ribi_t::sued) {
249
 
                                        setze_bild(besch->gib_bild_nr(0+direction*8));
 
249
                                        set_bild(besch->get_bild_nr(0+direction*8));
250
250
                                }
251
251
                        }
252
252
                        else {
253
253
                                // drive right ...
254
254
                                if(weg_dir&ribi_t::sued) {
255
255
                                        if(weg_dir&ribi_t::ost) {
256
 
                                                after_bild = besch->gib_bild_nr(4+direction*8);
 
256
                                                after_bild = besch->get_bild_nr(4+direction*8);
257
257
                                        }
258
258
                                        else {
259
 
                                                after_bild = besch->gib_bild_nr(0+direction*8);
 
259
                                                after_bild = besch->get_bild_nr(0+direction*8);
260
260
                                        }
261
261
                                }
262
262
                                else if(weg_dir&ribi_t::ost) {
263
 
                                        after_bild = besch->gib_bild_nr(2+direction*8);
 
263
                                        after_bild = besch->get_bild_nr(2+direction*8);
264
264
                                }
265
265
 
266
266
                                if(weg_dir&ribi_t::west) {
267
267
                                        if(weg_dir&ribi_t::nord) {
268
 
                                                setze_bild(besch->gib_bild_nr(5+direction*8));
 
268
                                                set_bild(besch->get_bild_nr(5+direction*8));
269
269
                                        }
270
270
                                        else {
271
 
                                                setze_bild(besch->gib_bild_nr(3+direction*8));
 
271
                                                set_bild(besch->get_bild_nr(3+direction*8));
272
272
                                        }
273
273
                                }
274
274
                                else if(weg_dir&ribi_t::nord) {
275
 
                                        setze_bild(besch->gib_bild_nr(1+direction*8));
 
275
                                        set_bild(besch->get_bild_nr(1+direction*8));
276
276
                                }
277
277
                        }
278
278
 
285
285
 
286
286
// only used for traffic light: change the current state
287
287
bool
288
 
roadsign_t::sync_step(long delta_t)
 
288
roadsign_t::sync_step(long /*delta_t*/)
289
289
{
290
290
        // change every ~16s hours in normal speed
291
 
        uint8 new_zustand = ( (welt->gib_zeit_ms()>>14) + welt->gib_einstellungen()->get_rotation() )&1;
 
291
        uint8 new_zustand = ( (welt->get_zeit_ms()>>14) + welt->get_einstellungen()->get_rotation() )&1;
292
292
        if(zustand!=new_zustand) {
293
293
                zustand = new_zustand;
294
294
                dir = (new_zustand==0) ? ribi_t::nordsued : ribi_t::ostwest;
319
319
{
320
320
        if(after_bild!=IMG_LEER) {
321
321
                const int raster_width = get_tile_raster_width();
322
 
                ypos += tile_raster_scale_x(gib_yoff()+after_offset, raster_width);
323
 
                xpos += tile_raster_scale_x(gib_xoff(), raster_width);
 
322
                ypos += tile_raster_scale_x(get_yoff()+after_offset, raster_width);
 
323
                xpos += tile_raster_scale_x(get_xoff(), raster_width);
324
324
                // draw with owner
325
325
                if(get_player_nr()!=-1) {
326
326
                        display_color_img(after_bild, xpos, ypos, get_player_nr(), true, get_flag(ding_t::dirty) );
336
336
void
337
337
roadsign_t::rdwr(loadsave_t *file)
338
338
{
 
339
        xml_tag_t r( file, "roadsign_t" );
 
340
 
339
341
        ding_t::rdwr(file);
340
342
 
341
343
        uint8 dummy=0;
347
349
        }
348
350
 
349
351
        if(file->is_saving()) {
350
 
                const char *s = besch->gib_name();
351
 
                file->rdwr_str(s, "N");
 
352
                const char *s = besch->get_name();
 
353
                file->rdwr_str(s);
352
354
        }
353
 
 
354
 
        if(file->is_loading()) {
 
355
        else {
355
356
                char bname[128];
356
 
                file->rd_str_into(bname, "N");
 
357
                file->rdwr_str(bname, 128);
357
358
 
358
359
                besch = roadsign_t::table.get(bname);
359
360
                if(besch==NULL) {
360
361
                        besch = roadsign_t::table.get(translator::compatibility_name(bname));
361
362
                        if(besch==NULL) {
362
 
                                dbg->warning("roadsign_t::rwdr", "description %s for roadsign/signal at %d,%d not found! (may be ignored)", bname, gib_pos().x, gib_pos().y);
 
363
                                dbg->warning("roadsign_t::rwdr", "description %s for roadsign/signal at %d,%d not found! (may be ignored)", bname, get_pos().x, get_pos().y);
363
364
                        }
364
365
                        else {
365
 
                                dbg->warning("roadsign_t::rwdr", "roadsign/signal %s at %d,%d rpleaced by %s", bname, gib_pos().x, gib_pos().y, besch->gib_name() );
 
366
                                dbg->warning("roadsign_t::rwdr", "roadsign/signal %s at %d,%d rpleaced by %s", bname, get_pos().x, get_pos().y, besch->get_name() );
366
367
                        }
367
368
                }
368
369
        }
374
375
void
375
376
roadsign_t::entferne(spieler_t *sp)
376
377
{
377
 
        spieler_t::accounting(sp, -besch->gib_preis(), gib_pos().gib_2d(), COST_CONSTRUCTION);
 
378
        spieler_t::accounting(sp, -besch->get_preis(), get_pos().get_2d(), COST_CONSTRUCTION);
378
379
}
379
380
 
380
381
 
387
388
 */
388
389
void roadsign_t::laden_abschliessen()
389
390
{
390
 
        grund_t *gr=welt->lookup(gib_pos());
391
 
        if(gr==NULL  ||  !gr->hat_weg(besch->gib_wtyp())) {
392
 
                dbg->error("roadsign_t::laden_abschliessen","roadsing: way/ground missing at %i,%i => ignore", gib_pos().x, gib_pos().y );
 
391
        grund_t *gr=welt->lookup(get_pos());
 
392
        if(gr==NULL  ||  !gr->hat_weg(besch->get_wtyp())) {
 
393
                dbg->error("roadsign_t::laden_abschliessen","roadsing: way/ground missing at %i,%i => ignore", get_pos().x, get_pos().y );
393
394
        }
394
395
        else {
395
396
                // after loading restore directions
396
397
                set_dir(dir);
397
 
                gr->gib_weg(besch->gib_wtyp())->count_sign();
 
398
                gr->get_weg(besch->get_wtyp())->count_sign();
398
399
        }
399
400
        // only traffic light need switches
400
401
        if(automatic) {
408
409
// to sort compare_roadsign_besch for always the same menu order
409
410
static bool compare_roadsign_besch(const roadsign_besch_t* a, const roadsign_besch_t* b)
410
411
{
411
 
        int diff = a->gib_wtyp() - b->gib_wtyp();
 
412
        int diff = a->get_wtyp() - b->get_wtyp();
412
413
        if (diff == 0) {
413
414
                if(a->is_free_route()) {
414
415
                        diff += 120;
420
421
        }
421
422
        if (diff == 0) {
422
423
                /* Some type: sort by name */
423
 
                diff = strcmp(a->gib_name(), b->gib_name());
 
424
                diff = strcmp(a->get_name(), b->get_name());
424
425
        }
425
426
        return diff < 0;
426
427
}
443
444
 
444
445
bool roadsign_t::register_besch(roadsign_besch_t *besch)
445
446
{
446
 
        roadsign_t::table.put(besch->gib_name(), besch);
447
 
        roadsign_t::liste.push_back(besch);
448
 
        if(besch->gib_wtyp()==track_wt  &&  besch->get_flags()==roadsign_besch_t::SIGN_SIGNAL) {
 
447
        roadsign_t::table.put(besch->get_name(), besch);
 
448
        roadsign_t::liste.append(besch);
 
449
        if(besch->get_wtyp()==track_wt  &&  besch->get_flags()==roadsign_besch_t::SIGN_SIGNAL) {
449
450
                default_signal = besch;
450
451
        }
451
 
        if(umgebung_t::drive_on_left  &&  besch->gib_wtyp()==road_wt) {
 
452
        if(umgebung_t::drive_on_left  &&  besch->get_wtyp()==road_wt) {
452
453
                // correct for driving on left side
453
454
                if(besch->is_traffic_light()) {
454
455
                        const int XOFF=(24*get_tile_raster_width())/64;
455
456
                        const int YOFF=(16*get_tile_raster_width())/64;
456
457
 
457
 
                        display_set_base_image_offset( besch->gib_bild_nr(0), -XOFF, -YOFF );
458
 
                        display_set_base_image_offset( besch->gib_bild_nr(8), -XOFF, -YOFF );
459
 
                        display_set_base_image_offset( besch->gib_bild_nr(1), +XOFF, +YOFF );
460
 
                        display_set_base_image_offset( besch->gib_bild_nr(9), +XOFF, +YOFF );
461
 
                        display_set_base_image_offset( besch->gib_bild_nr(2), -XOFF, +YOFF );
462
 
                        display_set_base_image_offset( besch->gib_bild_nr(10), -XOFF, +YOFF );
463
 
                        display_set_base_image_offset( besch->gib_bild_nr(3), +XOFF, -YOFF );
464
 
                        display_set_base_image_offset( besch->gib_bild_nr(11), +XOFF, -YOFF );
 
458
                        display_set_base_image_offset( besch->get_bild_nr(0), -XOFF, -YOFF );
 
459
                        display_set_base_image_offset( besch->get_bild_nr(8), -XOFF, -YOFF );
 
460
                        display_set_base_image_offset( besch->get_bild_nr(1), +XOFF, +YOFF );
 
461
                        display_set_base_image_offset( besch->get_bild_nr(9), +XOFF, +YOFF );
 
462
                        display_set_base_image_offset( besch->get_bild_nr(2), -XOFF, +YOFF );
 
463
                        display_set_base_image_offset( besch->get_bild_nr(10), -XOFF, +YOFF );
 
464
                        display_set_base_image_offset( besch->get_bild_nr(3), +XOFF, -YOFF );
 
465
                        display_set_base_image_offset( besch->get_bild_nr(11), +XOFF, -YOFF );
465
466
                }
466
467
                else if(!besch->is_free_route()) {
467
468
                        const int XOFF=(30*get_tile_raster_width())/64;
468
469
                        const int YOFF=(14*get_tile_raster_width())/64;
469
470
 
470
 
                        display_set_base_image_offset( besch->gib_bild_nr(0), -XOFF, -YOFF );
471
 
                        display_set_base_image_offset( besch->gib_bild_nr(1), +XOFF, +YOFF );
472
 
                        display_set_base_image_offset( besch->gib_bild_nr(2), -XOFF, +YOFF );
473
 
                        display_set_base_image_offset( besch->gib_bild_nr(3), +XOFF, -YOFF );
 
471
                        display_set_base_image_offset( besch->get_bild_nr(0), -XOFF, -YOFF );
 
472
                        display_set_base_image_offset( besch->get_bild_nr(1), +XOFF, +YOFF );
 
473
                        display_set_base_image_offset( besch->get_bild_nr(2), -XOFF, +YOFF );
 
474
                        display_set_base_image_offset( besch->get_bild_nr(3), +XOFF, -YOFF );
474
475
                }
475
476
        }
476
 
DBG_DEBUG( "roadsign_t::register_besch()","%s", besch->gib_name() );
 
477
DBG_DEBUG( "roadsign_t::register_besch()","%s", besch->get_name() );
477
478
        return true;
478
479
}
479
480
 
493
494
                const roadsign_besch_t* besch = (*iter);
494
495
                if(time==0  ||  (besch->get_intro_year_month()<=time  &&  besch->get_retire_year_month()>time)) {
495
496
 
496
 
                        if(besch->gib_cursor()->gib_bild_nr(1)!=IMG_LEER  &&  wtyp==besch->gib_wtyp()) {
 
497
                        if(besch->get_cursor()->get_bild_nr(1)!=IMG_LEER  &&  wtyp==besch->get_wtyp()) {
497
498
                                // only add items with a cursor
498
 
                                wkz_roadsign_t *wkz = sign_tool.get(besch->gib_name());
 
499
                                wkz_roadsign_t *wkz = sign_tool.get(besch->get_name());
499
500
                                if(wkz==NULL) {
500
501
                                        // not yet in hashtable
501
502
                                        wkz = new wkz_roadsign_t();
502
 
                                        wkz->icon = besch->gib_cursor()->gib_bild_nr(1),
503
 
                                        wkz->cursor = besch->gib_cursor()->gib_bild_nr(0),
504
 
                                        wkz->default_param = besch->gib_name();
505
 
                                        sign_tool.put(besch->gib_name(),wkz);
 
503
                                        wkz->set_icon( besch->get_cursor()->get_bild_nr(1) );
 
504
                                        wkz->cursor = besch->get_cursor()->get_bild_nr(0),
 
505
                                        wkz->default_param = besch->get_name();
 
506
                                        sign_tool.put(besch->get_name(),wkz);
506
507
                                }
507
508
                                wzw->add_werkzeug( (werkzeug_t*)wkz );
508
509
                        }
521
522
        for (vector_tpl<const roadsign_besch_t*>::const_iterator iter = liste.begin(), end = liste.end();  iter != end;  ++iter  ) {
522
523
                const roadsign_besch_t* besch = (*iter);
523
524
                if((time==0  ||  (besch->get_intro_year_month()<=time  &&  besch->get_retire_year_month()>time))
524
 
                        &&  besch->gib_wtyp()==wt  &&  besch->get_flags()==flag) {
 
525
                        &&  besch->get_wtyp()==wt  &&  besch->get_flags()==flag) {
525
526
                                return besch;
526
527
                }
527
528
        }