1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
|
/* $Id$ */
/** @file newgrf_station.c Functions for dealing with station classes and custom stations. */
#include "stdafx.h"
#include "openttd.h"
#include "variables.h"
#include "functions.h"
#include "debug.h"
#include "sprite.h"
#include "table/sprites.h"
#include "table/strings.h"
#include "station.h"
#include "station_map.h"
#include "newgrf_callbacks.h"
#include "newgrf_station.h"
#include "newgrf_spritegroup.h"
static StationClass station_classes[STAT_CLASS_MAX];
/**
* Reset station classes to their default state.
* This includes initialising the Default and Waypoint classes with an empty
* entry, for standard stations and waypoints.
*/
void ResetStationClasses(void)
{
StationClassID i;
for (i = 0; i < STAT_CLASS_MAX; i++) {
station_classes[i].id = 0;
station_classes[i].name = STR_EMPTY;
station_classes[i].stations = 0;
free(station_classes[i].spec);
station_classes[i].spec = NULL;
}
// Set up initial data
station_classes[0].id = 'DFLT';
station_classes[0].name = STR_STAT_CLASS_DFLT;
station_classes[0].stations = 1;
station_classes[0].spec = malloc(sizeof(*station_classes[0].spec));
station_classes[0].spec[0] = NULL;
station_classes[1].id = 'WAYP';
station_classes[1].name = STR_STAT_CLASS_WAYP;
station_classes[1].stations = 1;
station_classes[1].spec = malloc(sizeof(*station_classes[1].spec));
station_classes[1].spec[0] = NULL;
}
/**
* Allocate a station class for the given class id.
* @param classid A 32 bit value identifying the class.
* @return Index into station_classes of allocated class.
*/
StationClassID AllocateStationClass(uint32 class)
{
StationClassID i;
for (i = 0; i < STAT_CLASS_MAX; i++) {
if (station_classes[i].id == class) {
// ClassID is already allocated, so reuse it.
return i;
} else if (station_classes[i].id == 0) {
// This class is empty, so allocate it to the ClassID.
station_classes[i].id = class;
return i;
}
}
DEBUG(grf, 2)("StationClassAllocate: Already allocated %d classes, using default.", STAT_CLASS_MAX);
return STAT_CLASS_DFLT;
}
/** Set the name of a custom station class */
void SetStationClassName(StationClassID sclass, StringID name)
{
assert(sclass < STAT_CLASS_MAX);
station_classes[sclass].name = name;
}
/** Retrieve the name of a custom station class */
StringID GetStationClassName(StationClassID sclass)
{
assert(sclass < STAT_CLASS_MAX);
return station_classes[sclass].name;
}
/** Build a list of station class name StringIDs to use in a dropdown list
* @return Pointer to a (static) array of StringIDs
*/
StringID *BuildStationClassDropdown(void)
{
/* Allow room for all station classes, plus a terminator entry */
static StringID names[STAT_CLASS_MAX + 1];
uint i;
/* Add each name */
for (i = 0; i < STAT_CLASS_MAX && station_classes[i].id != 0; i++) {
names[i] = station_classes[i].name;
}
/* Terminate the list */
names[i] = INVALID_STRING_ID;
return names;
}
/**
* Get the number of station classes in use.
* @return Number of station classes.
*/
uint GetNumStationClasses(void)
{
uint i;
for (i = 0; i < STAT_CLASS_MAX && station_classes[i].id != 0; i++);
return i;
}
/**
* Return the number of stations for the given station class.
* @param sclass Index of the station class.
* @return Number of stations in the class.
*/
uint GetNumCustomStations(StationClassID sclass)
{
assert(sclass < STAT_CLASS_MAX);
return station_classes[sclass].stations;
}
/**
* Tie a station spec to its station class.
* @param spec The station spec.
*/
void SetCustomStationSpec(StationSpec *statspec)
{
StationClass *station_class;
int i;
assert(statspec->sclass < STAT_CLASS_MAX);
station_class = &station_classes[statspec->sclass];
i = station_class->stations++;
station_class->spec = realloc(station_class->spec, station_class->stations * sizeof(*station_class->spec));
station_class->spec[i] = statspec;
}
/**
* Retrieve a station spec from a class.
* @param sclass Index of the station class.
* @param station The station index with the class.
* @return The station spec.
*/
const StationSpec *GetCustomStationSpec(StationClassID sclass, uint station)
{
assert(sclass < STAT_CLASS_MAX);
if (station < station_classes[sclass].stations)
return station_classes[sclass].spec[station];
// If the custom station isn't defined any more, then the GRF file
// probably was not loaded.
return NULL;
}
const StationSpec *GetCustomStationSpecByGrf(uint32 grfid, byte localidx)
{
StationClassID i;
uint j;
for (i = STAT_CLASS_DFLT; i < STAT_CLASS_MAX; i++) {
for (j = 0; j < station_classes[i].stations; j++) {
const StationSpec *statspec = station_classes[i].spec[j];
if (statspec == NULL) continue;
if (statspec->grfid == grfid && statspec->localidx == localidx) return statspec;
}
}
return NULL;
}
/* Evaluate a tile's position within a station, and return the result a bitstuffed format.
* if not centred: .TNLcCpP, if centred: .TNL..CP
* T = Tile layout number (GetStationGfx), N = Number of platforms, L = Length of platforms
* C = Current platform number from start, c = from end
* P = Position along platform from start, p = from end
* if centred, C/P start from the centre and c/p are not available.
*/
uint32 GetPlatformInfo(Axis axis, byte tile, int platforms, int length, int x, int y, bool centred)
{
uint32 retval = 0;
if (axis == AXIS_X) {
intswap(platforms, length);
intswap(x, y);
}
/* Limit our sizes to 4 bits */
platforms = min(15, platforms);
length = min(15, length);
x = min(15, x);
y = min(15, y);
if (centred) {
x -= platforms / 2;
y -= length / 2;
SB(retval, 0, 4, clamp(y, -8, 7));
SB(retval, 4, 4, clamp(x, -8, 7));
} else {
SB(retval, 0, 4, y);
SB(retval, 4, 4, length - y - 1);
SB(retval, 8, 4, x);
SB(retval, 12, 4, platforms - x - 1);
}
SB(retval, 16, 4, length);
SB(retval, 20, 4, platforms);
SB(retval, 24, 4, tile);
return retval;
}
/* Find the end of a railway station, from the tile, in the direction of delta.
* If check_type is set, we stop if the custom station type changes.
* If check_axis is set, we stop if the station direction changes.
*/
static TileIndex FindRailStationEnd(TileIndex tile, TileIndexDiff delta, bool check_type, bool check_axis)
{
bool waypoint;
byte orig_type = 0;
Axis orig_axis = AXIS_X;
waypoint = IsTileType(tile, MP_RAILWAY);
if (waypoint) {
if (check_axis) orig_axis = GetWaypointAxis(tile);
} else {
if (check_type) orig_type = GetCustomStationSpecIndex(tile);
if (check_axis) orig_axis = GetRailStationAxis(tile);
}
while (true) {
TileIndex new_tile = TILE_ADD(tile, delta);
if (waypoint) {
if (!IsTileType(new_tile, MP_RAILWAY)) break;
if (GetRailTileType(new_tile) != RAIL_TYPE_DEPOT_WAYPOINT) break;
if (GetRailTileSubtype(new_tile) != RAIL_SUBTYPE_WAYPOINT) break;
if (check_axis && GetWaypointAxis(new_tile) != orig_axis) break;
} else {
if (!IsRailwayStationTile(new_tile)) break;
if (check_type && GetCustomStationSpecIndex(new_tile) != orig_type) break;
if (check_axis && GetRailStationAxis(new_tile) != orig_axis) break;
}
tile = new_tile;
}
return tile;
}
static uint32 GetPlatformInfoHelper(TileIndex tile, bool check_type, bool check_axis, bool centred)
{
int tx = TileX(tile);
int ty = TileY(tile);
int sx = TileX(FindRailStationEnd(tile, TileDiffXY(-1, 0), check_type, check_axis));
int sy = TileY(FindRailStationEnd(tile, TileDiffXY( 0, -1), check_type, check_axis));
int ex = TileX(FindRailStationEnd(tile, TileDiffXY( 1, 0), check_type, check_axis)) + 1;
int ey = TileY(FindRailStationEnd(tile, TileDiffXY( 0, 1), check_type, check_axis)) + 1;
Axis axis = IsTileType(tile, MP_RAILWAY) ? GetWaypointAxis(tile) : GetRailStationAxis(tile);
tx -= sx; ex -= sx;
ty -= sy; ey -= sy;
return GetPlatformInfo(axis, IsTileType(tile, MP_RAILWAY) ? 2 : GetStationGfx(tile), ex, ey, tx, ty, centred);
}
/* Station Resolver Functions */
static uint32 StationGetRandomBits(const ResolverObject *object)
{
const Station *st = object->u.station.st;
const TileIndex tile = object->u.station.tile;
return (st == NULL ? 0 : st->random_bits) | (tile == INVALID_TILE ? 0 : GetStationTileRandomBits(tile) << 16);
}
static uint32 StationGetTriggers(const ResolverObject *object)
{
const Station *st = object->u.station.st;
return st == NULL ? 0 : st->waiting_triggers;
}
static void StationSetTriggers(const ResolverObject *object, int triggers)
{
Station *st = (Station*)object->u.station.st;
assert(st != NULL);
st->waiting_triggers = triggers;
}
static uint32 StationGetVariable(const ResolverObject *object, byte variable, byte parameter)
{
const Station *st = object->u.station.st;
TileIndex tile = object->u.station.tile;
if (st == NULL) {
/* Station does not exist, so we're in a purchase list */
switch (variable) {
case 0x40:
case 0x41:
case 0x46:
case 0x47:
case 0x49: return 0x2110000; /* Platforms, tracks & position */
case 0x42: return 0; /* Rail type (XXX Get current type from GUI?) */
case 0x43: return _current_player; /* Station owner */
case 0x44: return 2; /* PBS status */
case 0xFA: return _date; /* Build date */
default: return -1;
}
}
switch (variable) {
/* Calculated station variables */
case 0x40: return GetPlatformInfoHelper(tile, false, false, false);
case 0x41: return GetPlatformInfoHelper(tile, true, false, false);
case 0x42: /* Terrain and rail type */
return ((_opt.landscape == LT_HILLY && GetTileZ(tile) > _opt.snow_line) ? 4 : 0) |
(GetRailType(tile) << 8);
case 0x43: return st->owner; /* Station owner */
case 0x44: return 2; /* PBS status */
case 0x46: return GetPlatformInfoHelper(tile, false, false, true);
case 0x47: return GetPlatformInfoHelper(tile, true, false, true);
case 0x48: { /* Accepted cargo types */
CargoID cargo_type;
uint32 value = 0;
for (cargo_type = 0; cargo_type < NUM_CARGO; cargo_type++) {
if (HASBIT(st->goods[cargo_type].waiting_acceptance, 15)) SETBIT(value, cargo_type);
}
return value;
}
case 0x49: return GetPlatformInfoHelper(tile, false, true, false);
/* Variables which use the parameter */
case 0x60: return GB(st->goods[parameter].waiting_acceptance, 0, 12);
case 0x61: return st->goods[parameter].days_since_pickup;
case 0x62: return st->goods[parameter].rating;
case 0x63: return st->goods[parameter].enroute_time;
case 0x64: return st->goods[parameter].last_speed | (st->goods[parameter].last_age << 8);
/* General station properties */
case 0x82: return 50;
case 0x84: return st->string_id;
case 0x86: return 0;
case 0x8A: return st->had_vehicle_of_type;
case 0xF0: return st->facilities;
case 0xF1: return st->airport_type;
case 0xF2: return st->truck_stops->status;
case 0xF3: return st->bus_stops->status;
case 0xF6: return st->airport_flags;
case 0xF7: return st->airport_flags & 0xFF;
case 0xFA: return st->build_date;
}
/* Handle cargo variables (deprecated) */
if (variable >= 0x8C && variable <= 0xEC) {
const GoodsEntry *g = &st->goods[GB(variable - 0x8C, 3, 4)];
switch (GB(variable - 0x8C, 0, 3)) {
case 0: return g->waiting_acceptance;
case 1: return g->waiting_acceptance & 0xFF;
case 2: return g->days_since_pickup;
case 3: return g->rating;
case 4: return g->enroute_from;
case 5: return g->enroute_time;
case 6: return g->last_speed;
case 7: return g->last_age;
}
}
DEBUG(grf, 1)("Unhandled station property 0x%X", variable);
return -1;
}
static const SpriteGroup *StationResolveReal(const ResolverObject *object, const SpriteGroup *group)
{
const Station *st = object->u.station.st;
const StationSpec *statspec = object->u.station.statspec;
uint set;
uint cargo = 0;
CargoID cargo_type = CT_INVALID; /* XXX Pick the correct cargo type */
if (st == NULL || statspec->sclass == STAT_CLASS_WAYP) {
return group->g.real.loading[0];
}
if (cargo_type == CT_INVALID) {
for (cargo_type = 0; cargo_type < NUM_CARGO; cargo_type++) {
cargo += GB(st->goods[cargo_type].waiting_acceptance, 0, 12);
}
} else {
cargo = GB(st->goods[cargo_type].waiting_acceptance, 0, 12);
}
if (HASBIT(statspec->flags, 1)) cargo /= (st->trainst_w + st->trainst_h);
cargo = min(0xfff, cargo);
if (cargo > statspec->cargo_threshold) {
if (group->g.real.num_loading > 0) {
set = ((cargo - statspec->cargo_threshold) * group->g.real.num_loading) / (0xfff - statspec->cargo_threshold);
return group->g.real.loading[set];
}
} else {
if (group->g.real.num_loaded > 0) {
set = (cargo * group->g.real.num_loaded) / (statspec->cargo_threshold + 1);
return group->g.real.loaded[set];
}
}
return group->g.real.loading[0];
}
static void NewStationResolver(ResolverObject *res, const StationSpec *statspec, const Station *st, TileIndex tile)
{
res->GetRandomBits = StationGetRandomBits;
res->GetTriggers = StationGetTriggers;
res->SetTriggers = StationSetTriggers;
res->GetVariable = StationGetVariable;
res->ResolveReal = StationResolveReal;
res->u.station.st = st;
res->u.station.statspec = statspec;
res->u.station.tile = tile;
res->callback = 0;
res->callback_param1 = 0;
res->callback_param2 = 0;
res->last_value = 0;
res->trigger = 0;
res->reseed = 0;
}
SpriteID GetCustomStationRelocation(const StationSpec *statspec, const Station *st, TileIndex tile)
{
const SpriteGroup *group;
ResolverObject object;
CargoID ctype = (st == NULL) ? GC_PURCHASE : GC_DEFAULT_NA;
NewStationResolver(&object, statspec, st, tile);
group = Resolve(statspec->spritegroup[ctype], &object);
if ((group == NULL || group->type != SGT_RESULT) && ctype != GC_DEFAULT_NA) {
group = Resolve(statspec->spritegroup[GC_DEFAULT_NA], &object);
}
if ((group == NULL || group->type != SGT_RESULT) && ctype != GC_DEFAULT) {
group = Resolve(statspec->spritegroup[GC_DEFAULT], &object);
}
if (group == NULL || group->type != SGT_RESULT) return 0;
return group->g.result.sprite;
}
uint16 GetStationCallback(uint16 callback, uint32 param1, uint32 param2, const StationSpec *statspec, const Station *st, TileIndex tile)
{
const SpriteGroup *group;
ResolverObject object;
CargoID ctype = (st == NULL) ? GC_PURCHASE : GC_DEFAULT_NA;
NewStationResolver(&object, statspec, st, tile);
object.callback = callback;
object.callback_param1 = param1;
object.callback_param2 = param2;
group = Resolve(statspec->spritegroup[ctype], &object);
if ((group == NULL || group->type != SGT_CALLBACK) && ctype != GC_DEFAULT_NA) {
group = Resolve(statspec->spritegroup[GC_DEFAULT_NA], &object);
}
if ((group == NULL || group->type != SGT_CALLBACK) && ctype != GC_DEFAULT) {
group = Resolve(statspec->spritegroup[GC_DEFAULT], &object);
}
if (group == NULL || group->type != SGT_CALLBACK) return CALLBACK_FAILED;
return group->g.callback.result;
}
/**
* Allocate a StationSpec to a Station. This is called once per build operation.
* @param spec StationSpec to allocate.
* @param st Station to allocate it to.
* @param exec Whether to actually allocate the spec.
* @return Index within the Station's spec list, or -1 if the allocation failed.
*/
int AllocateSpecToStation(const StationSpec *statspec, Station *st, bool exec)
{
uint i;
if (statspec == NULL) return 0;
/* Check if this spec has already been allocated */
for (i = 1; i < st->num_specs && i < 256; i++) {
if (st->speclist[i].spec == statspec) return i;
}
for (i = 1; i < st->num_specs && i < 256; i++) {
if (st->speclist[i].spec == NULL && st->speclist[i].grfid == 0) break;
}
if (i == 256) return -1;
if (exec) {
if (i >= st->num_specs) {
st->num_specs = i + 1;
st->speclist = realloc(st->speclist, st->num_specs * sizeof(*st->speclist));
if (st->num_specs == 2) {
/* Initial allocation */
st->speclist[0].spec = NULL;
st->speclist[0].grfid = 0;
st->speclist[0].localidx = 0;
}
}
st->speclist[i].spec = statspec;
st->speclist[i].grfid = statspec->grfid;
st->speclist[i].localidx = statspec->localidx;
}
return i;
}
/** Deallocate a StationSpec from a Station. Called when removing a single station tile.
* @param st Station to work with.
* @param specindex Index of the custom station within the Station's spec list.
* @return Indicates whether the StationSpec was deallocated.
*/
bool DeallocateSpecFromStation(Station *st, byte specindex)
{
bool freeable = true;
/* specindex of 0 (default) is never freeable */
if (specindex == 0) return false;
/* Check all tiles over the station to check if the specindex is still in use */
BEGIN_TILE_LOOP(tile, st->trainst_w, st->trainst_h, st->train_tile) {
if (IsTileType(tile, MP_STATION) && GetStationIndex(tile) == st->index && IsRailwayStation(tile) && GetCustomStationSpecIndex(tile) == specindex) {
freeable = false;
break;
}
} END_TILE_LOOP(tile, st->trainst_w, st->trainst_h, st->train_tile)
if (freeable) {
/* This specindex is no longer in use, so deallocate it */
st->speclist[specindex].spec = NULL;
st->speclist[specindex].grfid = 0;
st->speclist[specindex].localidx = 0;
/* If this was the highest spec index, reallocate */
if (specindex == st->num_specs - 1) {
for (; st->speclist[st->num_specs - 1].grfid == 0 && st->num_specs > 1; st->num_specs--);
if (st->num_specs > 1) {
st->speclist = realloc(st->speclist, st->num_specs * sizeof(*st->speclist));
} else {
free(st->speclist);
st->num_specs = 0;
st->speclist = NULL;
}
}
}
return freeable;
}
/** Draw representation of a station tile for GUI purposes.
* @param x, y Position of image.
* @param dir Direction.
* @param railtype Rail type.
* @param sclass, station Type of station.
* @return True if the tile was drawn (allows for fallback to default graphic)
*/
bool DrawStationTile(int x, int y, RailType railtype, Axis axis, StationClassID sclass, uint station)
{
extern uint16 _custom_sprites_base;
const StationSpec *statspec;
const DrawTileSprites *sprites;
const DrawTileSeqStruct *seq;
const RailtypeInfo *rti = GetRailTypeInfo(railtype);
SpriteID relocation;
PalSpriteID image;
PalSpriteID colourmod = SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player));
uint tile = 2;
statspec = GetCustomStationSpec(sclass, station);
if (statspec == NULL) return false;
relocation = GetCustomStationRelocation(statspec, NULL, INVALID_TILE);
if (HASBIT(statspec->callbackmask, CBM_CUSTOM_LAYOUT)) {
uint16 callback = GetStationCallback(CBID_STATION_SPRITE_LAYOUT, 0x2110000, 0, statspec, NULL, INVALID_TILE);
if (callback != CALLBACK_FAILED) tile = callback;
}
if (statspec->renderdata == NULL) {
sprites = GetStationTileLayout(tile + axis);
relocation -= 0x42D;
} else {
sprites = &statspec->renderdata[(tile < statspec->tiles) ? tile + axis : axis];
}
image = sprites->ground_sprite;
image += (image < _custom_sprites_base) ? rti->total_offset : rti->custom_ground_offset;
if (image & PALETTE_MODIFIER_COLOR) image &= SPRITE_MASK;
DrawSprite(image, x, y);
foreach_draw_tile_seq(seq, sprites->seq) {
Point pt;
image = seq->image + relocation;
if ((byte)seq->delta_z != 0x80) {
pt = RemapCoords(seq->delta_x, seq->delta_y, seq->delta_z);
DrawSprite((image & SPRITE_MASK) | colourmod, x + pt.x, y + pt.y);
}
}
return true;
}
|