1

/* $Id$ */

     2

     3

/** @file newgrf_generic.cpp Handling of generic feature callbacks. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "landscape.h"

     9

#include "debug.h"

    10

#include "newgrf.h"

    11

#include "newgrf_callbacks.h"

    12

#include "newgrf_commons.h"

    13

#include "newgrf_spritegroup.h"

    14

#include "newgrf_generic.h"

    15

#include "tile_map.h"

    16

#include <list>

    17

    18

    19

struct GenericCallback {

    20

	const GRFFile *file;

    21

	const SpriteGroup *group;

    22

    23

	GenericCallback(const GRFFile *file, const SpriteGroup *group) :

    24

		file(file),

    25

		group(group)

    26

	{ }

    27

};

    28

    29

typedef std::list<GenericCallback> GenericCallbackList;

    30

    31

static GenericCallbackList _gcl[GSF_END];

    32

    33

    34

/**

    35

 * Reset all generic feature callback sprite groups.

    36

 */

    37

void ResetGenericCallbacks()

    38

{

    39

	for (uint8 feature = 0; feature < lengthof(_gcl); feature++) {

    40

		_gcl[feature].clear();

    41

	}

    42

}

    43

    44

    45

/**

    46

 * Add a generic feature callback sprite group to the appropriate feature list.

    47

 * @param feature

    48

 * @param file

    49

 * @param group

    50

 */

    51

void AddGenericCallback(uint8 feature, const GRFFile *file, const SpriteGroup *group)

    52

{

    53

	if (feature >= lengthof(_gcl)) {

    54

		grfmsg(5, "AddGenericCallback: Unsupported feature 0x%02X", feature);

    55

		return;

    56

	}

    57

    58

	/* Generic feature callbacks are evaluated in reverse (i.e. the last group

    59

	 * to be added is evaluated first, etc) thus we push the group to the

    60

	 * beginning of the list so a standard iterator will do the right thing. */

    61

	_gcl[feature].push_front(GenericCallback(file, group));

    62

}

    63

    64

    65

static uint32 GenericCallbackGetRandomBits(const ResolverObject *object)

    66

{

    67

	return 0;

    68

}

    69

    70

    71

static uint32 GenericCallbackGetTriggers(const ResolverObject *object)

    72

{

    73

	return 0;

    74

}

    75

    76

    77

static void GenericCallbackSetTriggers(const ResolverObject *object, int triggers)

    78

{

    79

	return;

    80

}

    81

    82

    83

static uint32 GenericCallbackGetVariable(const ResolverObject *object, byte variable, byte parameter, bool *available)

    84

{

    85

	switch (variable) {

    86

		case 0x40: return object->u.generic.cargo_type;

    87

    88

		case 0x80: return object->u.generic.cargo_type;

    89

		case 0x81: return object->u.generic.cargo_type;

    90

		case 0x82: return object->u.generic.default_selection;

    91

		case 0x83: return object->u.generic.src_industry;

    92

		case 0x84: return object->u.generic.dst_industry;

    93

		case 0x85: return object->u.generic.distance;

    94

		case 0x86: return object->u.generic.event;

    95

		case 0x87: return object->u.generic.count;

    96

		case 0x88: return object->u.generic.station_size;

    97

    98

		default: break;

    99

	}

   100

   101

	DEBUG(grf, 1, "Unhandled generic feature property 0x%02X", variable);

   102

   103

	*available = false;

   104

	return 0;

   105

}

   106

   107

   108

static const SpriteGroup *GenericCallbackResolveReal(const ResolverObject *object, const SpriteGroup *group)

   109

{

   110

	if (group->g.real.num_loaded == 0) return NULL;

   111

   112

	return group->g.real.loaded[0];

   113

}

   114

   115

   116

static inline void NewGenericResolver(ResolverObject *res)

   117

{

   118

	res->GetRandomBits = &GenericCallbackGetRandomBits;

   119

	res->GetTriggers   = &GenericCallbackGetTriggers;

   120

	res->SetTriggers   = &GenericCallbackSetTriggers;

   121

	res->GetVariable   = &GenericCallbackGetVariable;

   122

	res->ResolveReal   = &GenericCallbackResolveReal;

   123

   124

	res->callback        = CBID_NO_CALLBACK;

   125

	res->callback_param1 = 0;

   126

	res->callback_param2 = 0;

   127

	res->last_value      = 0;

   128

	res->trigger         = 0;

   129

	res->reseed          = 0;

   130

	res->count           = 0;

   131

}

   132

   133

   134

/** Follow a generic feature callback list and return the first successful

   135

 * answer

   136

 * @param feature GRF Feature of callback

   137

 * @param object  pre-populated resolver object

   138

 * @param file    address of GRFFile object if file reference is needed, NULL is valid

   139

 * @return callback value if successful or CALLBACK_FAILED

   140

 */

   141

static uint16 GetGenericCallbackResult(uint8 feature, ResolverObject *object, const GRFFile **file)

   142

{

   143

	assert(feature < lengthof(_gcl));

   144

   145

	/* Test each feature callback sprite group. */

   146

	for (GenericCallbackList::const_iterator it = _gcl[feature].begin(); it != _gcl[feature].end(); ++it) {

   147

		const SpriteGroup *group = it->group;

   148

		group = Resolve(group, object);

   149

		if (group == NULL || group->type != SGT_CALLBACK) continue;

   150

   151

		/* Return NewGRF file if necessary */

   152

		if (file != NULL) *file = it->file;

   153

   154

		return group->g.callback.result;

   155

	}

   156

   157

	/* No callback returned a valid result, so we've failed. */

   158

	return CALLBACK_FAILED;

   159

}

   160

   161

   162

/**

   163

 * 'Execute' an AI purchase selection callback

   164

 */

   165

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)

   166

{

   167

	ResolverObject object;

   168

   169

	NewGenericResolver(&object);

   170

   171

	object.callback = CBID_GENERIC_AI_PURCHASE_SELECTION;

   172

	object.u.generic.cargo_type        = cargo_type;

   173

	object.u.generic.default_selection = default_selection;

   174

	object.u.generic.src_industry      = src_industry;

   175

	object.u.generic.dst_industry      = dst_industry;

   176

	object.u.generic.distance          = distance;

   177

	object.u.generic.event             = event;

   178

	object.u.generic.count             = count;

   179

	object.u.generic.station_size      = station_size;

   180

   181

	uint16 callback = GetGenericCallbackResult(feature, &object, file);

   182

	if (callback != CALLBACK_FAILED) callback = GB(callback, 0, 8);

   183

	return callback;

   184

}