OpenTTD: src/newgrf_generic.cpp Source File

OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

newgrf_generic.cpp
Go to the documentation of this file.
1 /* $Id: newgrf_generic.cpp 26482 2014-04-23 20:13:33Z rubidium $ */
2
3 /*
4 * This file is part of OpenTTD.
5 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8 */
9
12 #include "stdafx.h"
13 #include "debug.h"
14 #include "newgrf_spritegroup.h"
15 #include "industrytype.h"
16 #include "core/random_func.hpp"
17 #include "newgrf_sound.h"
18 #include "water_map.h"
19 #include <list>
20
21 #include "safeguards.h"
22
24 struct GenericScopeResolver : public ScopeResolver {
25 CargoID cargo_type;
26 uint8 default_selection;
27 uint8 src_industry;
28 uint8 dst_industry;
29 uint8 distance;
30 AIConstructionEvent event;
31 uint8 count;
32 uint8 station_size;
33
34 GenericScopeResolver(ResolverObject &ro, bool ai_callback);
35
36 /* virtual */ uint32 GetVariable(byte variable, uint32 parameter, bool *available) const;
37
38 private:
39 bool ai_callback;
40 };
41
42
44 struct GenericResolverObject : public ResolverObject {
45 GenericScopeResolver generic_scope;
46
47 GenericResolverObject(bool ai_callback, CallbackID callback = CBID_NO_CALLBACK);
48
49 /* virtual */ ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, byte relative = 0)
50 {
51 switch (scope) {
52 case VSG_SCOPE_SELF: return &this->generic_scope;
53 default: return ResolverObject::GetScope(scope, relative);
54 }
55 }
56
57 /* virtual */ const SpriteGroup *ResolveReal(const RealSpriteGroup *group) const;
58 };
59
60 struct GenericCallback {
61 const GRFFile *file;
62 const SpriteGroup *group;
63
64 GenericCallback(const GRFFile *file, const SpriteGroup *group) :
65 file(file),
66 group(group)
67 { }
68 };
69
70 typedef std::list<GenericCallback> GenericCallbackList;
71
72 static GenericCallbackList _gcl[GSF_END];
73
74
78 void ResetGenericCallbacks()
79 {
80 for (uint8 feature = 0; feature < lengthof(_gcl); feature++) {
81 _gcl[feature].clear();
82 }
83 }
84
85
92 void AddGenericCallback(uint8 feature, const GRFFile *file, const SpriteGroup *group)
93 {
94 if (feature >= lengthof(_gcl)) {
95 grfmsg(5, "AddGenericCallback: Unsupported feature 0x%02X", feature);
96 return;
97 }
98
99 /* Generic feature callbacks are evaluated in reverse (i.e. the last group
100 * to be added is evaluated first, etc) thus we push the group to the
101 * beginning of the list so a standard iterator will do the right thing. */
102 _gcl[feature].push_front(GenericCallback(file, group));
103 }
104
105 /* virtual */ uint32 GenericScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
106 {
107 if (this->ai_callback) {
108 switch (variable) {
109 case 0x40: return this->ro.grffile->cargo_map[this->cargo_type];
110
111 case 0x80: return this->cargo_type;
112 case 0x81: return CargoSpec::Get(this->cargo_type)->bitnum;
113 case 0x82: return this->default_selection;
114 case 0x83: return this->src_industry;
115 case 0x84: return this->dst_industry;
116 case 0x85: return this->distance;
117 case 0x86: return this->event;
118 case 0x87: return this->count;
119 case 0x88: return this->station_size;
120
121 default: break;
122 }
123 }
124
125 DEBUG(grf, 1, "Unhandled generic feature variable 0x%02X", variable);
126
127 *available = false;
128 return UINT_MAX;
129 }
130
131
132 /* virtual */ const SpriteGroup *GenericResolverObject::ResolveReal(const RealSpriteGroup *group) const
133 {
134 if (group->num_loaded == 0) return NULL;
135
136 return group->loaded[0];
137 }
138
144 GenericResolverObject::GenericResolverObject(bool ai_callback, CallbackID callback) : ResolverObject(NULL, callback), generic_scope(*this, ai_callback)
145 {
146 }
147
153 GenericScopeResolver::GenericScopeResolver(ResolverObject &ro, bool ai_callback) : ScopeResolver(ro)
154 {
155 this->cargo_type = 0;
156 this->default_selection = 0;
157 this->src_industry = 0;
158 this->dst_industry = 0;
159 this->distance = 0;
160 this->event = (AIConstructionEvent)0;
161 this->count = 0;
162 this->station_size = 0;
163 this->ai_callback = ai_callback;
164 }
165
166
178 static uint16 GetGenericCallbackResult(uint8 feature, ResolverObject &object, uint32 param1_grfv7, uint32 param1_grfv8, const GRFFile **file)
179 {
180 assert(feature < lengthof(_gcl));
181
182 /* Test each feature callback sprite group. */
183 for (GenericCallbackList::const_iterator it = _gcl[feature].begin(); it != _gcl[feature].end(); ++it) {
184 object.grffile = it->file;
185 object.root_spritegroup = it->group;
186 /* Set callback param based on GRF version. */
187 object.callback_param1 = it->file->grf_version >= 8 ? param1_grfv8 : param1_grfv7;
188 uint16 result = object.ResolveCallback();
189 if (result == CALLBACK_FAILED) continue;
190
191 /* Return NewGRF file if necessary */
192 if (file != NULL) *file = it->file;
193
194 return result;
195 }
196
197 /* No callback returned a valid result, so we've failed. */
198 return CALLBACK_FAILED;
199 }
200
201
218 uint16 GetAiPurchaseCallbackResult(uint8 feature, CargoID cargo_type, uint8 default_selection, IndustryType src_industry, IndustryType dst_industry, uint8 distance, AIConstructionEvent event, uint8 count, uint8 station_size, const GRFFile **file)
219 {
220 GenericResolverObject object(true, CBID_GENERIC_AI_PURCHASE_SELECTION);
221
222 if (src_industry != IT_AI_UNKNOWN && src_industry != IT_AI_TOWN) {
223 const IndustrySpec *is = GetIndustrySpec(src_industry);
224 /* If this is no original industry, use the substitute type */
225 if (is->grf_prop.subst_id != INVALID_INDUSTRYTYPE) src_industry = is->grf_prop.subst_id;
226 }
227
228 if (dst_industry != IT_AI_UNKNOWN && dst_industry != IT_AI_TOWN) {
229 const IndustrySpec *is = GetIndustrySpec(dst_industry);
230 /* If this is no original industry, use the substitute type */
231 if (is->grf_prop.subst_id != INVALID_INDUSTRYTYPE) dst_industry = is->grf_prop.subst_id;
232 }
233
234 object.generic_scope.cargo_type = cargo_type;
235 object.generic_scope.default_selection = default_selection;
236 object.generic_scope.src_industry = src_industry;
237 object.generic_scope.dst_industry = dst_industry;
238 object.generic_scope.distance = distance;
239 object.generic_scope.event = event;
240 object.generic_scope.count = count;
241 object.generic_scope.station_size = station_size;
242
243 uint16 callback = GetGenericCallbackResult(feature, object, 0, 0, file);
244 if (callback != CALLBACK_FAILED) callback = GB(callback, 0, 8);
245 return callback;
246 }
247
248
253 void AmbientSoundEffectCallback(TileIndex tile)
254 {
255 assert(IsTileType(tile, MP_CLEAR) || IsTileType(tile, MP_TREES) || IsTileType(tile, MP_WATER));
256
257 /* Only run every 1/200-th time. */
258 uint32 r; // Save for later
259 if (!Chance16R(1, 200, r) || !_settings_client.sound.ambient) return;
260
261 /* Prepare resolver object. */
262 GenericResolverObject object(false, CBID_SOUNDS_AMBIENT_EFFECT);
263
264 uint32 param1_v7 = GetTileType(tile) << 28 | Clamp(TileHeight(tile), 0, 15) << 24 | GB(r, 16, 8) << 16 | GetTerrainType(tile);
265 uint32 param1_v8 = GetTileType(tile) << 24 | GetTileZ(tile) << 16 | GB(r, 16, 8) << 8 | (HasTileWaterClass(tile) ? GetWaterClass(tile) : 0) << 3 | GetTerrainType(tile);
266
267 /* Run callback. */
268 const GRFFile *grf_file;
269 uint16 callback = GetGenericCallbackResult(GSF_SOUNDFX, object, param1_v7, param1_v8, &grf_file);
270
271 if (callback != CALLBACK_FAILED) PlayTileSound(grf_file, callback, tile);
272 }