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
|
/* $Id$ */
/** @file newgrf_spritegroup.h */
#ifndef NEWGRF_SPRITEGROUP_H
#define NEWGRF_SPRITEGROUP_H
#include "town.h"
#include "industry.h"
struct SpriteGroup;
/* 'Real' sprite groups contain a list of other result or callback sprite
* groups. */
struct RealSpriteGroup {
/* Loaded = in motion, loading = not moving
* Each group contains several spritesets, for various loading stages */
/* XXX: For stations the meaning is different - loaded is for stations
* with small amount of cargo whilst loading is for stations with a lot
* of da stuff. */
byte num_loaded; ///< Number of loaded groups
byte num_loading; ///< Number of loading groups
const SpriteGroup **loaded; ///< List of loaded groups (can be SpriteIDs or Callback results)
const SpriteGroup **loading; ///< List of loading groups (can be SpriteIDs or Callback results)
};
/* Shared by deterministic and random groups. */
enum VarSpriteGroupScope {
VSG_SCOPE_SELF,
/* Engine of consists for vehicles, city for stations. */
VSG_SCOPE_PARENT,
};
enum DeterministicSpriteGroupSize {
DSG_SIZE_BYTE,
DSG_SIZE_WORD,
DSG_SIZE_DWORD,
};
enum DeterministicSpriteGroupAdjustType {
DSGA_TYPE_NONE,
DSGA_TYPE_DIV,
DSGA_TYPE_MOD,
};
enum DeterministicSpriteGroupAdjustOperation {
DSGA_OP_ADD, ///< a + b
DSGA_OP_SUB, ///< a - b
DSGA_OP_SMIN, ///< (signed) min(a, b)
DSGA_OP_SMAX, ///< (signed) max(a, b)
DSGA_OP_UMIN, ///< (unsigned) min(a, b)
DSGA_OP_UMAX, ///< (unsigned) max(a, b)
DSGA_OP_SDIV, ///< (signed) a / b
DSGA_OP_SMOD, ///< (signed) a % b
DSGA_OP_UDIV, ///< (unsigned) a / b
DSGA_OP_UMOD, ///< (unsigned) a & b
DSGA_OP_MUL, ///< a * b
DSGA_OP_AND, ///< a & b
DSGA_OP_OR, ///< a | b
DSGA_OP_XOR, ///< a ^ b
DSGA_OP_STO, ///< store a into temporary storage, indexed by b. return a
DSGA_OP_RST, ///< return b
};
struct DeterministicSpriteGroupAdjust {
DeterministicSpriteGroupAdjustOperation operation;
DeterministicSpriteGroupAdjustType type;
byte variable;
byte parameter; ///< Used for variables between 0x60 and 0x7F inclusive.
byte shift_num;
uint32 and_mask;
uint32 add_val;
uint32 divmod_val;
const SpriteGroup *subroutine;
};
struct DeterministicSpriteGroupRange {
const SpriteGroup *group;
uint32 low;
uint32 high;
};
struct DeterministicSpriteGroup {
VarSpriteGroupScope var_scope;
DeterministicSpriteGroupSize size;
byte num_adjusts;
byte num_ranges;
DeterministicSpriteGroupAdjust *adjusts;
DeterministicSpriteGroupRange *ranges; // Dynamically allocated
/* Dynamically allocated, this is the sole owner */
const SpriteGroup *default_group;
};
enum RandomizedSpriteGroupCompareMode {
RSG_CMP_ANY,
RSG_CMP_ALL,
};
struct RandomizedSpriteGroup {
VarSpriteGroupScope var_scope; ///< Take this object:
RandomizedSpriteGroupCompareMode cmp_mode; ///< Check for these triggers:
byte triggers;
byte lowest_randbit; ///< Look for this in the per-object randomized bitmask:
byte num_groups; ///< must be power of 2
const SpriteGroup **groups; ///< Take the group with appropriate index:
};
/* This contains a callback result. A failed callback has a value of
* CALLBACK_FAILED */
struct CallbackResultSpriteGroup {
uint16 result;
};
/* A result sprite group returns the first SpriteID and the number of
* sprites in the set */
struct ResultSpriteGroup {
SpriteID sprite;
byte num_sprites;
};
struct TileLayoutSpriteGroup {
byte num_sprites; ///< Number of sprites in the spriteset, used for loading stages
struct DrawTileSprites *dts;
};
/* List of different sprite group types */
enum SpriteGroupType {
SGT_INVALID,
SGT_REAL,
SGT_DETERMINISTIC,
SGT_RANDOMIZED,
SGT_CALLBACK,
SGT_RESULT,
SGT_TILELAYOUT,
};
/* Common wrapper for all the different sprite group types */
struct SpriteGroup {
SpriteGroupType type;
union {
RealSpriteGroup real;
DeterministicSpriteGroup determ;
RandomizedSpriteGroup random;
CallbackResultSpriteGroup callback;
ResultSpriteGroup result;
TileLayoutSpriteGroup layout;
} g;
};
SpriteGroup *AllocateSpriteGroup();
void InitializeSpriteGroupPool();
struct ResolverObject {
uint16 callback;
uint32 callback_param1;
uint32 callback_param2;
byte trigger;
uint32 last_value;
uint32 reseed;
VarSpriteGroupScope scope;
bool info_view; ///< Indicates if the item is being drawn in an info window
union {
struct {
const struct Vehicle *self;
const struct Vehicle *parent;
EngineID self_type;
} vehicle;
struct {
TileIndex tile;
} canal;
struct {
TileIndex tile;
const struct Station *st;
const struct StationSpec *statspec;
CargoID cargo_type;
} station;
struct {
TileIndex tile;
Town *town;
HouseID house_id;
} house;
struct {
TileIndex tile;
Industry *ind;
IndustryGfx gfx;
} industry;
struct {
const struct CargoSpec *cs;
} cargo;
} u;
uint32 (*GetRandomBits)(const struct ResolverObject*);
uint32 (*GetTriggers)(const struct ResolverObject*);
void (*SetTriggers)(const struct ResolverObject*, int);
uint32 (*GetVariable)(const struct ResolverObject*, byte, byte, bool*);
const SpriteGroup *(*ResolveReal)(const struct ResolverObject*, const SpriteGroup*);
};
/* Base sprite group resolver */
const SpriteGroup *Resolve(const SpriteGroup *group, ResolverObject *object);
#endif /* NEWGRF_SPRITEGROUP_H */
|
