← Back to branch summary

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

« back to all changes in this revision

Viewing changes to simwerkz.h

  • 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:
simwerkz.h
12
12
#include "simworld.h"
13
13
#include "simmenu.h"
14
14
#include "simwin.h"
 
15
#include "simdings.h"
15
16
 
16
17
#include "besch/way_obj_besch.h"
17
18
 
18
 
#include "bauer/fabrikbauer.h"
 
19
#include "boden/wege/schiene.h"
19
20
 
20
21
#include "dataobj/umgebung.h"
21
22
#include "dataobj/translator.h"
31
32
class koord3d;
32
33
class koord;
33
34
class wegbauer_t;
 
35
class haus_besch_t;
34
36
class roadsign_besch_t;
35
37
class weg_besch_t;
36
38
class route_t;
45
47
class wkz_abfrage_t : public werkzeug_t {
46
48
public:
47
49
        wkz_abfrage_t() : werkzeug_t() { id = WKZ_ABFRAGE | GENERAL_TOOL; }
48
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Abfrage"); }
 
50
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Abfrage"); }
49
51
        const char *work( karte_t *, spieler_t *, koord3d );
50
52
        virtual bool is_init_network_save() const { return true; }
51
53
        virtual bool is_work_network_save() const { return true; }
58
60
        static bool wkz_remover_intern(spieler_t *sp, karte_t *welt, koord3d pos, const char *&msg);
59
61
public:
60
62
        wkz_remover_t() : werkzeug_t() { id = WKZ_REMOVER | GENERAL_TOOL; }
61
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Abriss"); }
 
63
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Abriss"); }
62
64
        const char *work( karte_t *, spieler_t *, koord3d );
63
65
        virtual bool is_init_network_save() const { return true; }
64
66
};
70
72
        sint16 drag_height;
71
73
public:
72
74
        wkz_raise_t() : werkzeug_t() { offset = Z_GRID; id = WKZ_RAISE_LAND | GENERAL_TOOL; }
73
 
        const char *get_tooltip(spieler_t *sp) { return tooltip_with_price("Anheben", sp->get_welt()->get_einstellungen()->cst_alter_land); }
 
75
        const char *get_tooltip(const spieler_t *sp) const { return tooltip_with_price("Anheben", sp->get_welt()->get_settings().cst_alter_land); }
74
76
        virtual image_id get_icon(spieler_t *) const { return grund_t::underground_mode==grund_t::ugm_all ? IMG_LEER : icon; }
75
77
        bool init( karte_t *, spieler_t * ) { is_dragging = false; return true; }
76
78
        bool exit( karte_t *, spieler_t * ) { is_dragging = false; return true; }
86
88
        sint16 drag_height;
87
89
public:
88
90
        wkz_lower_t() : werkzeug_t() { offset = Z_GRID; id = WKZ_LOWER_LAND | GENERAL_TOOL;  }
89
 
        const char *get_tooltip(spieler_t *sp) { return tooltip_with_price("Absenken", sp->get_welt()->get_einstellungen()->cst_alter_land); }
 
91
        const char *get_tooltip(const spieler_t *sp) const { return tooltip_with_price("Absenken", sp->get_welt()->get_settings().cst_alter_land); }
90
92
        virtual image_id get_icon(spieler_t *) const { return grund_t::underground_mode==grund_t::ugm_all ? IMG_LEER : icon; }
91
93
        bool init( karte_t *, spieler_t * ) { is_dragging = false; return true; }
92
94
        bool exit( karte_t *, spieler_t * ) { is_dragging = false; return true; }
101
103
public:
102
104
        wkz_setslope_t() : werkzeug_t() { id = WKZ_SETSLOPE | GENERAL_TOOL; }
103
105
        static const char *wkz_set_slope_work( karte_t *welt, spieler_t *sp, koord3d pos, int slope );
104
 
        const char *get_tooltip(spieler_t *sp) { return tooltip_with_price("Built artifical slopes", sp->get_welt()->get_einstellungen()->cst_set_slope); }
 
106
        const char *get_tooltip(const spieler_t *sp) const { return tooltip_with_price("Built artifical slopes", sp->get_welt()->get_settings().cst_set_slope); }
105
107
        virtual bool is_init_network_save() const { return true; }
106
108
        const char *check( karte_t *, spieler_t *, koord3d );
107
109
        virtual const char *work( karte_t *welt, spieler_t *sp, koord3d k ) { return wkz_set_slope_work( welt, sp, k, atoi(default_param) ); }
110
112
class wkz_restoreslope_t : public werkzeug_t {
111
113
public:
112
114
        wkz_restoreslope_t() : werkzeug_t() { id = WKZ_RESTORESLOPE | GENERAL_TOOL; }
113
 
        const char *get_tooltip(spieler_t *sp) { return tooltip_with_price("Restore natural slope", sp->get_welt()->get_einstellungen()->cst_set_slope); }
 
115
        const char *get_tooltip(const spieler_t *sp) const { return tooltip_with_price("Restore natural slope", sp->get_welt()->get_settings().cst_set_slope); }
114
116
        virtual bool is_init_network_save() const { return true; }
115
117
        const char *check( karte_t *, spieler_t *, koord3d );
116
118
        virtual const char *work( karte_t *welt, spieler_t *sp, koord3d k ) { return wkz_setslope_t::wkz_set_slope_work( welt, sp, k, RESTORE_SLOPE ); }
119
121
class wkz_marker_t : public kartenboden_werkzeug_t {
120
122
public:
121
123
        wkz_marker_t() : kartenboden_werkzeug_t() { id = WKZ_MARKER | GENERAL_TOOL; }
122
 
        const char *get_tooltip(spieler_t *sp) { return tooltip_with_price("Marker", sp->get_welt()->get_einstellungen()->cst_buy_land); }
 
124
        const char *get_tooltip(const spieler_t *sp) const { return tooltip_with_price("Marker", sp->get_welt()->get_settings().cst_buy_land); }
123
125
        virtual const char *work( karte_t *welt, spieler_t *sp, koord3d k );
124
126
        virtual bool is_init_network_save() const { return true; }
125
127
};
127
129
class wkz_clear_reservation_t : public werkzeug_t {
128
130
public:
129
131
        wkz_clear_reservation_t() : werkzeug_t() { id = WKZ_CLEAR_RESERVATION | GENERAL_TOOL; }
130
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Clear block reservation"); }
 
132
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Clear block reservation"); }
131
133
        bool init( karte_t *, spieler_t * );
132
134
        bool exit( karte_t *, spieler_t * );
133
135
        virtual const char *work( karte_t *, spieler_t *, koord3d );
137
139
class wkz_transformer_t : public kartenboden_werkzeug_t {
138
140
public:
139
141
        wkz_transformer_t() : kartenboden_werkzeug_t() { id = WKZ_TRANSFORMER | GENERAL_TOOL; }
140
 
        const char *get_tooltip(spieler_t *);
 
142
        const char *get_tooltip(const spieler_t *) const;
141
143
        virtual const char *work( karte_t *, spieler_t *, koord3d );
142
144
        virtual bool is_init_network_save() const { return true; }
143
145
};
145
147
class wkz_add_city_t : public kartenboden_werkzeug_t {
146
148
public:
147
149
        wkz_add_city_t() : kartenboden_werkzeug_t() { id = WKZ_ADD_CITY | GENERAL_TOOL; }
148
 
        const char *get_tooltip(spieler_t *sp) { return tooltip_with_price( "Found new city", sp->get_welt()->get_einstellungen()->cst_found_city ); }
 
150
        const char *get_tooltip(const spieler_t *sp) const { return tooltip_with_price("Found new city", sp->get_welt()->get_settings().cst_found_city); }
149
151
        virtual const char *work( karte_t *, spieler_t *, koord3d );
150
152
        virtual bool is_init_network_save() const { return true; }
151
153
};
154
156
class wkz_buy_house_t : public kartenboden_werkzeug_t {
155
157
public:
156
158
        wkz_buy_house_t() : kartenboden_werkzeug_t() { id = WKZ_BUY_HOUSE | GENERAL_TOOL; }
157
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Haus kaufen"); }
 
159
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Haus kaufen"); }
158
160
        const char *work( karte_t *, spieler_t *, koord3d );
159
161
        virtual bool is_init_network_save() const { return true; }
160
162
};
164
166
class wkz_change_city_size_t : public werkzeug_t {
165
167
public:
166
168
        wkz_change_city_size_t() : werkzeug_t() { id = WKZ_CHANGE_CITY_SIZE | GENERAL_TOOL; }
167
 
        const char *get_tooltip(spieler_t *) { return translator::translate( atoi(default_param)>=0 ? "Grow city" : "Shrink city" ); }
 
169
        const char *get_tooltip(const spieler_t *) const { return translator::translate( atoi(default_param)>=0 ? "Grow city" : "Shrink city" ); }
168
170
        bool init( karte_t *, spieler_t * );
169
171
        virtual const char *work( karte_t *, spieler_t *, koord3d );
170
172
        virtual bool is_init_network_save() const { return true; }
173
175
class wkz_plant_tree_t : public kartenboden_werkzeug_t {
174
176
public:
175
177
        wkz_plant_tree_t() : kartenboden_werkzeug_t() { id = WKZ_PLANT_TREE | GENERAL_TOOL; }
176
 
        const char *get_tooltip(spieler_t *) { return translator::translate( "Plant tree" ); }
 
178
        const char *get_tooltip(const spieler_t *) const { return translator::translate( "Plant tree" ); }
177
179
        virtual const char *move( karte_t *welt, spieler_t *sp, uint16 b, koord3d k ) { return b==1 ? work(welt,sp,k) : NULL; }
178
180
        virtual const char *work( karte_t *, spieler_t *, koord3d );
179
181
        virtual bool is_init_network_save() const { return true; }
216
218
public:
217
219
        wkz_wegebau_t() : two_click_werkzeug_t(), besch(NULL) { id = WKZ_WEGEBAU | GENERAL_TOOL; }
218
220
        virtual image_id get_icon(spieler_t *) const;
219
 
        virtual const char *get_tooltip(spieler_t *);
 
221
        virtual const char *get_tooltip(const spieler_t *) const;
220
222
        virtual const char* get_default_param(spieler_t *) const;
221
 
        virtual bool is_selected( karte_t *welt ) const;
 
223
        virtual bool is_selected(const karte_t *welt ) const;
222
224
        virtual bool init( karte_t *, spieler_t * );
223
225
        virtual bool is_move_network_save(spieler_t *sp) const { return two_click_werkzeug_t::is_move_network_save(sp) && (besch  &&  (besch->get_styp()!=1  ||  besch->get_wtyp()==air_wt)); }
224
226
        virtual bool is_init_network_save() const { return true; }
231
233
        wkz_build_cityroad() : wkz_wegebau_t() { id = WKZ_CITYROAD | GENERAL_TOOL; }
232
234
        virtual const weg_besch_t *get_besch(uint16,bool) const;
233
235
        virtual image_id get_icon(spieler_t *sp) const { return werkzeug_t::get_icon(sp); }
234
 
        virtual bool is_selected( karte_t *welt ) const { return werkzeug_t::is_selected(welt); }
 
236
        virtual bool is_selected(const karte_t *welt ) const { return werkzeug_t::is_selected(welt); }
235
237
        virtual bool is_init_network_save() const { return true; }
236
238
};
237
239
 
245
247
public:
246
248
        wkz_brueckenbau_t() : two_click_werkzeug_t() { id = WKZ_BRUECKENBAU | GENERAL_TOOL; }
247
249
        virtual image_id get_icon(spieler_t *) const { return grund_t::underground_mode==grund_t::ugm_all ? IMG_LEER : icon; }
248
 
        const char *get_tooltip(spieler_t *);
 
250
        const char *get_tooltip(const spieler_t *) const;
249
251
        virtual bool is_move_network_save(spieler_t *) const { return false;}
250
252
        virtual bool is_init_network_save() const { return true; }
251
253
};
258
260
        virtual uint8 is_valid_pos( karte_t *, spieler_t *, const koord3d &, const char *&, const koord3d & );
259
261
public:
260
262
        wkz_tunnelbau_t() : two_click_werkzeug_t() { id = WKZ_TUNNELBAU | GENERAL_TOOL; }
261
 
        const char *get_tooltip(spieler_t *);
 
263
        const char *get_tooltip(const spieler_t *) const;
262
264
        virtual bool is_move_network_save(spieler_t *) const { return false;}
263
265
        const char *check( karte_t *, spieler_t *, koord3d );
264
266
        virtual bool is_init_network_save() const { return true; }
274
276
        const char *calc_route_error;
275
277
public:
276
278
        wkz_wayremover_t() : two_click_werkzeug_t() { id = WKZ_WAYREMOVER | GENERAL_TOOL; }
277
 
        const char *get_tooltip(spieler_t *);
 
279
        const char *get_tooltip(const spieler_t *) const;
278
280
        virtual bool is_init_network_save() const { return true; }
279
281
};
280
282
 
295
297
 
296
298
public:
297
299
        wkz_wayobj_t(bool b=true) : two_click_werkzeug_t(), build(b) { id = WKZ_WAYOBJ | GENERAL_TOOL; };
298
 
        virtual const char *get_tooltip(spieler_t *);
299
 
        virtual bool is_selected(karte_t *welt) const;
 
300
        virtual const char *get_tooltip(const spieler_t *) const;
 
301
        virtual bool is_selected(const karte_t *welt) const;
300
302
        virtual bool init( karte_t *, spieler_t * );
301
303
        virtual bool is_init_network_save() const { return true; }
302
304
};
304
306
class wkz_wayobj_remover_t : public wkz_wayobj_t {
305
307
public:
306
308
        wkz_wayobj_remover_t() : wkz_wayobj_t(false) { id = WKZ_REMOVE_WAYOBJ | GENERAL_TOOL; }
307
 
        virtual bool is_selected(karte_t *welt) const { return werkzeug_t::is_selected( welt ); }
 
309
        virtual bool is_selected(const karte_t *welt) const { return werkzeug_t::is_selected( welt ); }
308
310
        virtual bool is_init_network_save() const { return true; }
309
311
};
310
312
 
318
320
public:
319
321
        wkz_station_t() : werkzeug_t() { id = WKZ_STATION | GENERAL_TOOL; }
320
322
        virtual image_id get_icon(spieler_t *) const;
321
 
        const char *get_tooltip(spieler_t *);
 
323
        const char *get_tooltip(const spieler_t *) const;
322
324
        bool init( karte_t *, spieler_t * );
323
325
        const char *check( karte_t *, spieler_t *, koord3d );
324
326
        virtual const char *work( karte_t *, spieler_t *, koord3d );
346
348
 
347
349
public:
348
350
        wkz_roadsign_t();
349
 
        const char *get_tooltip(spieler_t *);
 
351
        const char *get_tooltip(const spieler_t *) const;
350
352
        bool init( karte_t *, spieler_t * );
351
353
        bool exit( karte_t *welt, spieler_t *sp );
352
354
 
364
366
public:
365
367
        wkz_depot_t() : werkzeug_t() { id = WKZ_DEPOT | GENERAL_TOOL; }
366
368
        virtual image_id get_icon(spieler_t *sp) const { return sp->get_player_nr()==1 ? IMG_LEER : icon; }
367
 
        const char *get_tooltip(spieler_t *);
 
369
        const char *get_tooltip(const spieler_t *) const;
368
370
        bool init( karte_t *, spieler_t * );
369
371
        virtual const char *work( karte_t *, spieler_t *, koord3d );
370
372
        virtual bool is_init_network_save() const { return true; }
381
383
class wkz_build_haus_t : public kartenboden_werkzeug_t {
382
384
public:
383
385
        wkz_build_haus_t() : kartenboden_werkzeug_t() { id = WKZ_BUILD_HAUS | GENERAL_TOOL; }
384
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Built random attraction"); }
 
386
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Built random attraction"); }
385
387
        bool init( karte_t *, spieler_t * );
386
388
        virtual const char *work( karte_t *, spieler_t *, koord3d );
387
389
        virtual bool is_init_network_save() const { return true; }
399
401
class wkz_build_industries_land_t : public kartenboden_werkzeug_t {
400
402
public:
401
403
        wkz_build_industries_land_t() : kartenboden_werkzeug_t() { id = WKZ_LAND_CHAIN | GENERAL_TOOL; }
402
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Build land consumer"); }
 
404
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Build land consumer"); }
403
405
        bool init( karte_t *, spieler_t * );
404
406
        virtual const char *work( karte_t *, spieler_t *, koord3d );
405
407
        virtual bool is_init_network_save() const { return true; }
408
410
class wkz_build_industries_city_t : public kartenboden_werkzeug_t {
409
411
public:
410
412
        wkz_build_industries_city_t() : kartenboden_werkzeug_t() { id = WKZ_CITY_CHAIN | GENERAL_TOOL; }
411
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Build city market"); }
 
413
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Build city market"); }
412
414
        bool init( karte_t *, spieler_t * );
413
415
        virtual const char *work( karte_t *, spieler_t *, koord3d );
414
416
        virtual bool is_init_network_save() const { return true; }
417
419
class wkz_build_factory_t : public kartenboden_werkzeug_t {
418
420
public:
419
421
        wkz_build_factory_t() : kartenboden_werkzeug_t() { id = WKZ_BUILD_FACTORY | GENERAL_TOOL; }
420
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Build city market"); }
 
422
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Build city market"); }
421
423
        bool init( karte_t *, spieler_t * );
422
424
        virtual const char *work( karte_t *, spieler_t *, koord3d );
423
425
        virtual bool is_init_network_save() const { return true; }
426
428
class wkz_link_factory_t : public two_click_werkzeug_t {
427
429
public:
428
430
        wkz_link_factory_t() : two_click_werkzeug_t() { id = WKZ_LINK_FACTORY | GENERAL_TOOL; }
429
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Connect factory"); }
 
431
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Connect factory"); }
430
432
        virtual bool is_init_network_save() const { return true; }
431
433
private:
432
434
        virtual const char *do_work( karte_t *, spieler_t *, const koord3d &, const koord3d & );
437
439
 
438
440
class wkz_headquarter_t : public kartenboden_werkzeug_t {
439
441
private:
440
 
        const haus_besch_t *next_level( spieler_t *sp );
 
442
        const haus_besch_t *next_level( const spieler_t *sp ) const;
441
443
public:
442
444
        wkz_headquarter_t() : kartenboden_werkzeug_t() { id = WKZ_HEADQUARTER | GENERAL_TOOL; }
443
 
        const char *get_tooltip(spieler_t *);
 
445
        const char *get_tooltip(const spieler_t *) const;
444
446
        bool init( karte_t *, spieler_t * );
445
447
        virtual const char *work( karte_t *, spieler_t *, koord3d );
446
448
        virtual bool is_init_network_save() const { return true; }
450
452
class wkz_lock_game_t : public werkzeug_t {
451
453
public:
452
454
        wkz_lock_game_t() : werkzeug_t() { id = WKZ_LOCK_GAME | GENERAL_TOOL; }
453
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Lock game"); }
 
455
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Lock game"); }
454
456
        const char *work( karte_t *welt, spieler_t *, koord3d );
455
457
        virtual bool is_init_network_save() const { return true; }
456
458
};
459
461
class wkz_add_citycar_t : public werkzeug_t {
460
462
public:
461
463
        wkz_add_citycar_t() : werkzeug_t() { id = WKZ_ADD_CITYCAR | GENERAL_TOOL; }
462
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Add random citycar"); }
 
464
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Add random citycar"); }
463
465
        virtual const char *work( karte_t *, spieler_t *, koord3d );
464
466
        virtual bool is_init_network_save() const { return true; }
465
467
};
468
470
class wkz_forest_t : public two_click_werkzeug_t {
469
471
public:
470
472
        wkz_forest_t() : two_click_werkzeug_t() { id = WKZ_FOREST | GENERAL_TOOL; }
471
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Add forest"); }
 
473
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Add forest"); }
472
474
private:
473
475
        virtual const char *do_work( karte_t *, spieler_t *, const koord3d &, const koord3d & );
474
476
        virtual void mark_tiles( karte_t *, spieler_t *, const koord3d &, const koord3d & );
483
485
        halthandle_t last_halt;
484
486
public:
485
487
        wkz_stop_moving_t() : two_click_werkzeug_t() { id = WKZ_STOP_MOVER | GENERAL_TOOL; }
486
 
        const char *get_tooltip(spieler_t *) { return translator::translate("replace stop"); }
 
488
        const char *get_tooltip(const spieler_t *) const { return translator::translate("replace stop"); }
487
489
        virtual bool is_init_network_save() const { return true; }
488
490
 
489
491
private:
502
504
        wkz_make_stop_public_t() : werkzeug_t() { id = WKZ_MAKE_STOP_PUBLIC | GENERAL_TOOL;  }
503
505
        bool init( karte_t *, spieler_t * );
504
506
        bool exit( karte_t *w, spieler_t *s ) { return init(w,s); }
505
 
        const char *get_tooltip(spieler_t *);
 
507
        const char *get_tooltip(const spieler_t *) const;
506
508
        virtual const char *move( karte_t *, spieler_t *, uint16 /* buttonstate */, koord3d );
507
509
        virtual const char *work( karte_t *, spieler_t *, koord3d );
508
510
        virtual bool is_init_network_save() const { return true; }
513
515
class wkz_pause_t : public werkzeug_t {
514
516
public:
515
517
        wkz_pause_t() : werkzeug_t() { id = WKZ_PAUSE | SIMPLE_TOOL; }
516
 
        const char *get_tooltip(spieler_t *) { return umgebung_t::networkmode ? translator::translate("deactivated in online mode") : translator::translate("Pause"); }
 
518
        const char *get_tooltip(const spieler_t *) const { return umgebung_t::networkmode ? translator::translate("deactivated in online mode") : translator::translate("Pause"); }
517
519
        image_id get_icon(spieler_t *) const { return umgebung_t::networkmode ? IMG_LEER : icon; }
518
 
        bool is_selected(karte_t *welt) const { return welt->is_paused(); }
 
520
        bool is_selected(const karte_t *welt) const { return welt->is_paused(); }
519
521
        bool init( karte_t *welt, spieler_t * ) {
520
522
                if(  !umgebung_t::networkmode  ) {
521
523
                        welt->set_fast_forward(0);
531
533
class wkz_fastforward_t : public werkzeug_t {
532
534
public:
533
535
        wkz_fastforward_t() : werkzeug_t() { id = WKZ_FASTFORWARD | SIMPLE_TOOL; }
534
 
        const char *get_tooltip(spieler_t *) { return umgebung_t::networkmode ? translator::translate("deactivated in online mode") : translator::translate("Fast forward"); }
 
536
        const char *get_tooltip(const spieler_t *) const { return umgebung_t::networkmode ? translator::translate("deactivated in online mode") : translator::translate("Fast forward"); }
535
537
        image_id get_icon(spieler_t *) const { return umgebung_t::networkmode ? IMG_LEER : icon; }
536
 
        bool is_selected(karte_t *welt) const { return welt->is_fast_forward(); }
 
538
        bool is_selected(const karte_t *welt) const { return welt->is_fast_forward(); }
537
539
        bool init( karte_t *welt, spieler_t * ) {
538
540
                if(  !umgebung_t::networkmode  ) {
539
541
                        welt->set_pause(0);
549
551
class wkz_screenshot_t : public werkzeug_t {
550
552
public:
551
553
        wkz_screenshot_t() : werkzeug_t() { id = WKZ_SCREENSHOT | SIMPLE_TOOL; }
552
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Screenshot"); }
 
554
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Screenshot"); }
553
555
        bool init( karte_t *, spieler_t * ) {
554
556
                display_snapshot();
555
557
                create_win( new news_img("Screenshot\ngespeichert.\n"), w_time_delete, magic_none);
563
565
class wkz_increase_industry_t : public werkzeug_t {
564
566
public:
565
567
        wkz_increase_industry_t() : werkzeug_t() { id = WKZ_INCREASE_INDUSTRY | SIMPLE_TOOL; }
566
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Increase Industry density"); }
567
 
        bool init( karte_t *welt, spieler_t * ) {
568
 
                fabrikbauer_t::increase_industry_density( welt, false );
569
 
                return false;
570
 
        }
 
568
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Increase Industry density"); }
 
569
        bool init( karte_t *welt, spieler_t * );
571
570
};
572
571
 
573
572
/* prissi: undo building */
574
573
class wkz_undo_t : public werkzeug_t {
575
574
public:
576
575
        wkz_undo_t() : werkzeug_t() { id = WKZ_UNDO | SIMPLE_TOOL; }
577
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Undo last ways construction"); }
 
576
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Undo last ways construction"); }
578
577
        bool init( karte_t *, spieler_t *sp ) {
579
578
                if(!sp->undo()  &&  is_local_execution()) {
580
579
                        create_win( new news_img("UNDO failed!"), w_time_delete, magic_none);
589
588
class wkz_switch_player_t : public werkzeug_t {
590
589
public:
591
590
        wkz_switch_player_t() : werkzeug_t() { id = WKZ_SWITCH_PLAYER | SIMPLE_TOOL; }
592
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Change player"); }
 
591
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Change player"); }
593
592
        bool init( karte_t *welt, spieler_t * ) {
594
593
                welt->switch_active_player( welt->get_active_player_nr()+1, true );
595
594
                return false;
603
602
class wkz_step_year_t : public werkzeug_t {
604
603
public:
605
604
        wkz_step_year_t() : werkzeug_t() { id = WKZ_STEP_YEAR | SIMPLE_TOOL; }
606
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Step timeline one year"); }
 
605
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Step timeline one year"); }
607
606
        bool init( karte_t *welt, spieler_t * ) {
608
607
                welt->step_year();
609
608
                return false;
613
612
class wkz_change_game_speed_t : public werkzeug_t {
614
613
public:
615
614
        wkz_change_game_speed_t() : werkzeug_t() { id = WKZ_CHANGE_GAME_SPEED | SIMPLE_TOOL; }
616
 
        const char *get_tooltip(spieler_t *) {
 
615
        const char *get_tooltip(const spieler_t *) const {
617
616
                int faktor = atoi(default_param);
618
617
                return faktor>0 ? translator::translate("Accelerate time") : translator::translate("Deccelerate time");
619
618
        }
626
625
class wkz_zoom_in_t : public werkzeug_t {
627
626
public:
628
627
        wkz_zoom_in_t() : werkzeug_t() { id = WKZ_ZOOM_IN | SIMPLE_TOOL; }
629
 
        const char *get_tooltip(spieler_t *) { return translator::translate("zooming in"); }
 
628
        const char *get_tooltip(const spieler_t *) const { return translator::translate("zooming in"); }
630
629
        bool init( karte_t *welt, spieler_t * ) {
631
630
                win_change_zoom_factor(true);
632
631
                welt->set_dirty();
639
638
class wkz_zoom_out_t : public werkzeug_t {
640
639
public:
641
640
        wkz_zoom_out_t() : werkzeug_t() { id = WKZ_ZOOM_OUT | SIMPLE_TOOL; }
642
 
        const char *get_tooltip(spieler_t *) { return translator::translate("zooming out"); }
 
641
        const char *get_tooltip(const spieler_t *) const { return translator::translate("zooming out"); }
643
642
        bool init( karte_t *welt, spieler_t * ) {
644
643
                win_change_zoom_factor(false);
645
644
                welt->set_dirty();
652
651
class wkz_show_coverage_t : public werkzeug_t {
653
652
public:
654
653
        wkz_show_coverage_t() : werkzeug_t() { id = WKZ_SHOW_COVERAGE | SIMPLE_TOOL; }
655
 
        const char *get_tooltip(spieler_t *) { return translator::translate("show station coverage"); }
656
 
        bool is_selected(karte_t *) const { return umgebung_t::station_coverage_show; }
 
654
        const char *get_tooltip(const spieler_t *) const { return translator::translate("show station coverage"); }
 
655
        bool is_selected(const karte_t *) const { return umgebung_t::station_coverage_show; }
657
656
        bool init( karte_t *welt, spieler_t * ) {
658
657
                umgebung_t::station_coverage_show = !umgebung_t::station_coverage_show;
659
658
                welt->set_dirty();
667
666
class wkz_show_name_t : public werkzeug_t {
668
667
public:
669
668
        wkz_show_name_t() : werkzeug_t() { id = WKZ_SHOW_NAMES | SIMPLE_TOOL; }
670
 
        const char *get_tooltip(spieler_t *) {
 
669
        const char *get_tooltip(const spieler_t *) const {
671
670
                return translator::translate(
672
671
                        (umgebung_t::show_names>>2)==2 ? "hide station names" :
673
672
                        (umgebung_t::show_names&1) ? "show waiting bars" : "show station names");
700
699
class wkz_show_grid_t : public werkzeug_t {
701
700
public:
702
701
        wkz_show_grid_t() : werkzeug_t() { id = WKZ_SHOW_GRID | SIMPLE_TOOL; }
703
 
        const char *get_tooltip(spieler_t *) { return translator::translate("show grid"); }
704
 
        bool is_selected(karte_t *) const { return grund_t::show_grid; }
 
702
        const char *get_tooltip(const spieler_t *) const { return translator::translate("show grid"); }
 
703
        bool is_selected(const karte_t *) const { return grund_t::show_grid; }
705
704
        bool init( karte_t *welt, spieler_t * ) {
706
705
                grund_t::toggle_grid();
707
706
                welt->set_dirty();
715
714
class wkz_show_trees_t : public werkzeug_t {
716
715
public:
717
716
        wkz_show_trees_t() : werkzeug_t() { id = WKZ_SHOW_TREES | SIMPLE_TOOL; }
718
 
        const char *get_tooltip(spieler_t *) { return translator::translate("hide trees"); }
719
 
        bool is_selected(karte_t *) const { return umgebung_t::hide_trees; }
 
717
        const char *get_tooltip(const spieler_t *) const { return translator::translate("hide trees"); }
 
718
        bool is_selected(const karte_t *) const { return umgebung_t::hide_trees; }
720
719
        bool init( karte_t *welt, spieler_t * ) {
721
720
                umgebung_t::hide_trees = !umgebung_t::hide_trees;
722
721
                welt->set_dirty();
730
729
class wkz_show_houses_t : public werkzeug_t {
731
730
public:
732
731
        wkz_show_houses_t() : werkzeug_t() { id = WKZ_SHOW_HOUSES | SIMPLE_TOOL; }
733
 
        const char *get_tooltip(spieler_t *) {
 
732
        const char *get_tooltip(const spieler_t *) const {
734
733
                return translator::translate(
735
734
                        umgebung_t::hide_buildings==0 ? "hide city building" :
736
735
                        (umgebung_t::hide_buildings==1) ? "hide all building" : "show all building");
751
750
public:
752
751
        wkz_show_underground_t() : werkzeug_t() { id = WKZ_SHOW_UNDERGROUND | SIMPLE_TOOL; }
753
752
        static sint8 save_underground_level;
754
 
        const char *get_tooltip(spieler_t *);
755
 
        bool is_selected(karte_t *) const;
 
753
        const char *get_tooltip(const spieler_t *) const;
 
754
        bool is_selected(const karte_t *) const;
756
755
        void draw_after( karte_t *w, koord pos ) const;
757
756
        bool init( karte_t *welt, spieler_t * );
758
757
        virtual const char *work( karte_t *, spieler_t *, koord3d );
765
764
public:
766
765
        wkz_rotate90_t() : werkzeug_t() { id = WKZ_ROTATE90 | SIMPLE_TOOL; }
767
766
        image_id get_icon(spieler_t *) const { return umgebung_t::networkmode ? IMG_LEER : icon; }
768
 
        const char *get_tooltip(spieler_t *) { return umgebung_t::networkmode ? translator::translate("deactivated in online mode") : translator::translate("Rotate map"); }
 
767
        const char *get_tooltip(const spieler_t *) const { return umgebung_t::networkmode ? translator::translate("deactivated in online mode") : translator::translate("Rotate map"); }
769
768
        bool init( karte_t *welt, spieler_t * ) {
770
769
                if(  !umgebung_t::networkmode  ) {
771
770
                        welt->rotate90();
780
779
class wkz_quit_t : public werkzeug_t {
781
780
public:
782
781
        wkz_quit_t() : werkzeug_t() { id = WKZ_QUIT | SIMPLE_TOOL; }
783
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Beenden"); }
 
782
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Beenden"); }
784
783
        bool init( karte_t *welt, spieler_t * ) {
785
784
                destroy_all_win( true );
786
785
                welt->beenden( true );
794
793
class wkz_fill_trees_t : public werkzeug_t {
795
794
public:
796
795
        wkz_fill_trees_t() : werkzeug_t() { id = WKZ_FILL_TREES | SIMPLE_TOOL; }
797
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Fill trees"); }
 
796
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Fill trees"); }
798
797
        bool init( karte_t *welt, spieler_t * ) {
799
798
                if(  default_param  ) {
800
799
                        baum_t::fill_trees( welt, atoi(default_param) );
807
806
class wkz_daynight_level_t : public werkzeug_t {
808
807
public:
809
808
        wkz_daynight_level_t() : werkzeug_t() { id = WKZ_DAYNIGHT_LEVEL | SIMPLE_TOOL; }
810
 
        const char *get_tooltip(spieler_t *);
 
809
        const char *get_tooltip(const spieler_t *) const;
811
810
        bool init( karte_t *, spieler_t * );
812
811
        virtual bool is_init_network_save() const { return true; }
813
812
        virtual bool is_work_network_save() const { return true; }
814
813
};
815
814
 
816
 
 
817
 
/* change day/night view manually */
818
815
class wkz_vehicle_tooltips_t : public werkzeug_t {
819
816
public:
820
817
        wkz_vehicle_tooltips_t() : werkzeug_t() { id = WKZ_VEHICLE_TOOLTIPS | SIMPLE_TOOL; }
821
 
        const char *get_tooltip(spieler_t *) { return translator::translate("Toggle vehicle tooltips"); }
822
 
        bool init( karte_t *, spieler_t * ) {
 
818
        const char *get_tooltip(const spieler_t *) const { return translator::translate("Toggle vehicle tooltips"); }
 
819
        bool init( karte_t *welt, spieler_t * ) {
823
820
                umgebung_t::show_vehicle_states = (umgebung_t::show_vehicle_states+1)%3;
 
821
                welt->set_dirty();
824
822
                return false;
825
823
        }
826
824
        virtual bool is_init_network_save() const { return true; }
830
828
class wkz_toggle_pax_station_t : public werkzeug_t {
831
829
public:
832
830
        wkz_toggle_pax_station_t() : werkzeug_t() { id = WKZ_TOOGLE_PAX | SIMPLE_TOOL; }
833
 
        const char *get_tooltip(spieler_t *) { return translator::translate("5LIGHT_CHOOSE"); }
834
 
        bool is_selected(karte_t *welt) const { return welt->get_einstellungen()->get_show_pax(); }
 
831
        const char *get_tooltip(const spieler_t *) const { return translator::translate("5LIGHT_CHOOSE"); }
 
832
        bool is_selected(const karte_t *welt) const { return welt->get_settings().get_show_pax(); }
835
833
        bool init( karte_t *welt, spieler_t * ) {
836
 
                welt->access_einstellungen()->set_show_pax( !welt->get_einstellungen()->get_show_pax() );
 
834
                settings_t& s = welt->get_settings();
 
835
                s.set_show_pax(!s.get_show_pax());
837
836
                return false;
838
837
        }
839
838
        bool exit( karte_t *w, spieler_t *s ) { return init(w,s); }
843
842
class wkz_toggle_pedestrians_t : public werkzeug_t {
844
843
public:
845
844
        wkz_toggle_pedestrians_t() : werkzeug_t() { id = WKZ_TOOGLE_PEDESTRIANS | SIMPLE_TOOL; }
846
 
        const char *get_tooltip(spieler_t *) { return translator::translate("6LIGHT_CHOOSE"); }
847
 
        bool is_selected(karte_t *welt) const { return welt->get_einstellungen()->get_random_pedestrians(); }
 
845
        const char *get_tooltip(const spieler_t *) const { return translator::translate("6LIGHT_CHOOSE"); }
 
846
        bool is_selected(const karte_t *welt) const { return welt->get_settings().get_random_pedestrians(); }
848
847
        bool init( karte_t *welt, spieler_t * ) {
849
 
                welt->access_einstellungen()->set_random_pedestrians( !welt->get_einstellungen()->get_random_pedestrians() );
 
848
                settings_t& s = welt->get_settings();
 
849
                s.set_random_pedestrians(!s.get_random_pedestrians());
850
850
                return false;
851
851
        }
852
852
        bool exit( karte_t *w, spieler_t *s ) { return init(w,s); }
853
853
        virtual bool is_init_network_save() const { return false; }
854
854
};
855
855
 
 
856
class wkz_toggle_reservation_t : public werkzeug_t {
 
857
public:
 
858
        wkz_toggle_reservation_t() : werkzeug_t() { id = WKZ_TOGGLE_RESERVATION | SIMPLE_TOOL; }
 
859
        const char *get_tooltip(const spieler_t *) const { return translator::translate("show/hide block reservations"); }
 
860
        bool is_selected(const karte_t*) const { return schiene_t::show_reservations; }
 
861
        bool init( karte_t *welt, spieler_t * ) {
 
862
                schiene_t::show_reservations ^= 1;
 
863
                welt->set_dirty();
 
864
                return false;
 
865
        }
 
866
        virtual bool is_init_network_save() const { return true; }
 
867
        virtual bool is_work_network_save() const { return true; }
 
868
};
 
869
 
 
870
class wkz_view_owner_t : public werkzeug_t {
 
871
public:
 
872
        wkz_view_owner_t() : werkzeug_t() { id = WKZ_VIEW_OWNER | SIMPLE_TOOL; }
 
873
        const char *get_tooltip(const spieler_t *) const { return translator::translate("show/hide object owner"); }
 
874
        bool is_selected(const karte_t*) const { return ding_t::show_owner; }
 
875
        bool init( karte_t *welt, spieler_t * ) {
 
876
                ding_t::show_owner ^= 1;
 
877
                welt->set_dirty();
 
878
                return false;
 
879
        }
 
880
        virtual bool is_init_network_save() const { return true; }
 
881
        virtual bool is_work_network_save() const { return true; }
 
882
};
 
883
 
 
884
/******************************** Internal tools ***********/
856
885
/* internal simple tools needed for networksynchronisation */
857
886
class wkz_traffic_level_t : public werkzeug_t {
858
887
public:
859
888
        wkz_traffic_level_t() : werkzeug_t() { id = WKZ_TRAFFIC_LEVEL | SIMPLE_TOOL; }
860
 
        const char *get_tooltip(spieler_t *) { return translator::translate("6WORLD_CHOOSE"); }
861
 
        bool is_selected(karte_t *) const { return false; }
 
889
        const char *get_tooltip(const spieler_t *) const { return translator::translate("6WORLD_CHOOSE"); }
 
890
        bool is_selected(const karte_t *) const { return false; }
862
891
        bool init( karte_t *welt, spieler_t * ) {
863
892
                assert(  default_param  );
864
 
                welt->access_einstellungen()->set_verkehr_level( atoi(default_param) );
 
893
                welt->get_settings().set_verkehr_level(atoi(default_param));
865
894
                return false;
866
895
        }
867
896
        virtual bool is_init_network_save() const { return false; }