Files
@ r10045:f6d1b92735b7
Branch filter:
Location: cpp/openttd-patchpack/source/src/newgrf_generic.cpp
r10045:f6d1b92735b7
5.1 KiB
text/x-c
(svn r14205) -Update: WebTranslator2 update to 2008-08-31 19:47:56
bulgarian - 12 fixed by thetitan (12)
catalan - 49 fixed by arnaullv (49)
czech - 4 fixed, 15 changed by Hadez (19)
dutch - 2 fixed, 5 changed by habell (7)
french - 2 fixed, 1 changed by belugas (1), glx (2)
galician - 75 fixed, 54 changed by Condex (129)
german - 10 fixed, 1 changed by dih (11)
italian - 5 fixed, 5 changed by lorenzodv (10)
korean - 14 fixed by leejaeuk5 (14)
slovenian - 6 fixed by Necrolyte (6)
turkish - 18 fixed by jnmbk (18)
ukrainian - 2 fixed by mad (2)
bulgarian - 12 fixed by thetitan (12)
catalan - 49 fixed by arnaullv (49)
czech - 4 fixed, 15 changed by Hadez (19)
dutch - 2 fixed, 5 changed by habell (7)
french - 2 fixed, 1 changed by belugas (1), glx (2)
galician - 75 fixed, 54 changed by Condex (129)
german - 10 fixed, 1 changed by dih (11)
italian - 5 fixed, 5 changed by lorenzodv (10)
korean - 14 fixed by leejaeuk5 (14)
slovenian - 6 fixed by Necrolyte (6)
turkish - 18 fixed by jnmbk (18)
ukrainian - 2 fixed by mad (2)
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 | /* $Id$ */
/** @file newgrf_generic.cpp Handling of generic feature callbacks. */
#include "stdafx.h"
#include "openttd.h"
#include "variables.h"
#include "landscape.h"
#include "debug.h"
#include "newgrf.h"
#include "newgrf_callbacks.h"
#include "newgrf_commons.h"
#include "newgrf_spritegroup.h"
#include "newgrf_generic.h"
#include "tile_map.h"
#include <list>
struct GenericCallback {
const GRFFile *file;
const SpriteGroup *group;
GenericCallback(const GRFFile *file, const SpriteGroup *group) :
file(file),
group(group)
{ }
};
typedef std::list<GenericCallback> GenericCallbackList;
static GenericCallbackList _gcl[GSF_END];
/**
* Reset all generic feature callback sprite groups.
*/
void ResetGenericCallbacks()
{
for (uint8 feature = 0; feature < lengthof(_gcl); feature++) {
_gcl[feature].clear();
}
}
/**
* Add a generic feature callback sprite group to the appropriate feature list.
* @param feature
* @param file
* @param group
*/
void AddGenericCallback(uint8 feature, const GRFFile *file, const SpriteGroup *group)
{
if (feature >= lengthof(_gcl)) {
grfmsg(5, "AddGenericCallback: Unsupported feature 0x%02X", feature);
return;
}
/* Generic feature callbacks are evaluated in reverse (i.e. the last group
* to be added is evaluated first, etc) thus we push the group to the
* beginning of the list so a standard iterator will do the right thing. */
_gcl[feature].push_front(GenericCallback(file, group));
}
static uint32 GenericCallbackGetRandomBits(const ResolverObject *object)
{
return 0;
}
static uint32 GenericCallbackGetTriggers(const ResolverObject *object)
{
return 0;
}
static void GenericCallbackSetTriggers(const ResolverObject *object, int triggers)
{
return;
}
static uint32 GenericCallbackGetVariable(const ResolverObject *object, byte variable, byte parameter, bool *available)
{
switch (variable) {
case 0x40: return object->u.generic.cargo_type;
case 0x80: return object->u.generic.cargo_type;
case 0x81: return object->u.generic.cargo_type;
case 0x82: return object->u.generic.default_selection;
case 0x83: return object->u.generic.src_industry;
case 0x84: return object->u.generic.dst_industry;
case 0x85: return object->u.generic.distance;
case 0x86: return object->u.generic.event;
case 0x87: return object->u.generic.count;
case 0x88: return object->u.generic.station_size;
default: break;
}
DEBUG(grf, 1, "Unhandled generic feature property 0x%02X", variable);
*available = false;
return 0;
}
static const SpriteGroup *GenericCallbackResolveReal(const ResolverObject *object, const SpriteGroup *group)
{
if (group->g.real.num_loaded == 0) return NULL;
return group->g.real.loaded[0];
}
static inline void NewGenericResolver(ResolverObject *res, const GRFFile *grffile)
{
res->GetRandomBits = &GenericCallbackGetRandomBits;
res->GetTriggers = &GenericCallbackGetTriggers;
res->SetTriggers = &GenericCallbackSetTriggers;
res->GetVariable = &GenericCallbackGetVariable;
res->ResolveReal = &GenericCallbackResolveReal;
res->callback = CBID_NO_CALLBACK;
res->callback_param1 = 0;
res->callback_param2 = 0;
res->last_value = 0;
res->trigger = 0;
res->reseed = 0;
res->count = 0;
res->grffile = grffile;
}
/** Follow a generic feature callback list and return the first successful
* answer
* @param feature GRF Feature of callback
* @param object pre-populated resolver object
* @param file address of GRFFile object if file reference is needed, NULL is valid
* @return callback value if successful or CALLBACK_FAILED
*/
static uint16 GetGenericCallbackResult(uint8 feature, ResolverObject *object, const GRFFile **file)
{
assert(feature < lengthof(_gcl));
/* Test each feature callback sprite group. */
for (GenericCallbackList::const_iterator it = _gcl[feature].begin(); it != _gcl[feature].end(); ++it) {
const SpriteGroup *group = it->group;
group = Resolve(group, object);
if (group == NULL || group->type != SGT_CALLBACK) continue;
/* Return NewGRF file if necessary */
if (file != NULL) *file = it->file;
return group->g.callback.result;
}
/* No callback returned a valid result, so we've failed. */
return CALLBACK_FAILED;
}
/**
* 'Execute' an AI purchase selection callback
*/
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)
{
ResolverObject object;
NewGenericResolver(&object, *file);
object.callback = CBID_GENERIC_AI_PURCHASE_SELECTION;
object.u.generic.cargo_type = cargo_type;
object.u.generic.default_selection = default_selection;
object.u.generic.src_industry = src_industry;
object.u.generic.dst_industry = dst_industry;
object.u.generic.distance = distance;
object.u.generic.event = event;
object.u.generic.count = count;
object.u.generic.station_size = station_size;
uint16 callback = GetGenericCallbackResult(feature, &object, file);
if (callback != CALLBACK_FAILED) callback = GB(callback, 0, 8);
return callback;
}
|