1

/* $Id$ */

     2

     3

/** @file newgrf_spritegroup.h */

     4

     5

#ifndef NEWGRF_SPRITEGROUP_H

     6

#define NEWGRF_SPRITEGROUP_H

     7

     8

#include "town_type.h"

     9

#include "industry_type.h"

    10

#include "core/bitmath_func.hpp"

    11

#include "gfx_type.h"

    12

#include "engine_type.h"

    13

#include "tile_type.h"

    14

    15

#include "newgrf_cargo.h"

    16

#include "newgrf_callbacks.h"

    17

#include "newgrf_generic.h"

    18

#include "newgrf_storage.h"

    19

    20

/**

    21

 * Gets the value of a so-called newgrf "register".

    22

 * @param i index of the register

    23

 * @pre i < 0x110

    24

 * @return the value of the register

    25

 */

    26

static inline uint32 GetRegister(uint i)

    27

{

    28

	extern TemporaryStorageArray<uint32, 0x110> _temp_store;

    29

	return _temp_store.Get(i);

    30

}

    31

    32

struct SpriteGroup;

    33

    34

    35

/* 'Real' sprite groups contain a list of other result or callback sprite

    36

 * groups. */

    37

struct RealSpriteGroup {

    38

	/* Loaded = in motion, loading = not moving

    39

	 * Each group contains several spritesets, for various loading stages */

    40

    41

	/* XXX: For stations the meaning is different - loaded is for stations

    42

	 * with small amount of cargo whilst loading is for stations with a lot

    43

	 * of da stuff. */

    44

    45

	byte num_loaded;       ///< Number of loaded groups

    46

	byte num_loading;      ///< Number of loading groups

    47

	const SpriteGroup **loaded;  ///< List of loaded groups (can be SpriteIDs or Callback results)

    48

	const SpriteGroup **loading; ///< List of loading groups (can be SpriteIDs or Callback results)

    49

};

    50

    51

/* Shared by deterministic and random groups. */

    52

enum VarSpriteGroupScope {

    53

	VSG_SCOPE_SELF,

    54

	/* Engine of consists for vehicles, city for stations. */

    55

	VSG_SCOPE_PARENT,

    56

	/* Any vehicle in the consist (vehicles only) */

    57

	VSG_SCOPE_RELATIVE,

    58

};

    59

    60

enum DeterministicSpriteGroupSize {

    61

	DSG_SIZE_BYTE,

    62

	DSG_SIZE_WORD,

    63

	DSG_SIZE_DWORD,

    64

};

    65

    66

enum DeterministicSpriteGroupAdjustType {

    67

	DSGA_TYPE_NONE,

    68

	DSGA_TYPE_DIV,

    69

	DSGA_TYPE_MOD,

    70

};

    71

    72

enum DeterministicSpriteGroupAdjustOperation {

    73

	DSGA_OP_ADD,  ///< a + b

    74

	DSGA_OP_SUB,  ///< a - b

    75

	DSGA_OP_SMIN, ///< (signed) min(a, b)

    76

	DSGA_OP_SMAX, ///< (signed) max(a, b)

    77

	DSGA_OP_UMIN, ///< (unsigned) min(a, b)

    78

	DSGA_OP_UMAX, ///< (unsigned) max(a, b)

    79

	DSGA_OP_SDIV, ///< (signed) a / b

    80

	DSGA_OP_SMOD, ///< (signed) a % b

    81

	DSGA_OP_UDIV, ///< (unsigned) a / b

    82

	DSGA_OP_UMOD, ///< (unsigned) a & b

    83

	DSGA_OP_MUL,  ///< a * b

    84

	DSGA_OP_AND,  ///< a & b

    85

	DSGA_OP_OR,   ///< a | b

    86

	DSGA_OP_XOR,  ///< a ^ b

    87

	DSGA_OP_STO,  ///< store a into temporary storage, indexed by b. return a

    88

	DSGA_OP_RST,  ///< return b

    89

	DSGA_OP_STOP, ///< store a into persistent storage, indexed by b, return a

    90

	DSGA_OP_ROR,  ///< rotate a b positions to the right

    91

	DSGA_OP_SCMP, ///< (signed) comparision (a < b -> 0, a == b = 1, a > b = 2)

    92

	DSGA_OP_UCMP, ///< (unsigned) comparision (a < b -> 0, a == b = 1, a > b = 2)

    93

};

    94

    95

    96

struct DeterministicSpriteGroupAdjust {

    97

	DeterministicSpriteGroupAdjustOperation operation;

    98

	DeterministicSpriteGroupAdjustType type;

    99

	byte variable;

   100

	byte parameter; ///< Used for variables between 0x60 and 0x7F inclusive.

   101

	byte shift_num;

   102

	uint32 and_mask;

   103

	uint32 add_val;

   104

	uint32 divmod_val;

   105

	const SpriteGroup *subroutine;

   106

};

   107

   108

   109

struct DeterministicSpriteGroupRange {

   110

	const SpriteGroup *group;

   111

	uint32 low;

   112

	uint32 high;

   113

};

   114

   115

   116

struct DeterministicSpriteGroup {

   117

	VarSpriteGroupScope var_scope;

   118

	DeterministicSpriteGroupSize size;

   119

	byte num_adjusts;

   120

	byte num_ranges;

   121

	DeterministicSpriteGroupAdjust *adjusts;

   122

	DeterministicSpriteGroupRange *ranges; // Dynamically allocated

   123

   124

	/* Dynamically allocated, this is the sole owner */

   125

	const SpriteGroup *default_group;

   126

};

   127

   128

enum RandomizedSpriteGroupCompareMode {

   129

	RSG_CMP_ANY,

   130

	RSG_CMP_ALL,

   131

};

   132

   133

struct RandomizedSpriteGroup {

   134

	VarSpriteGroupScope var_scope;  ///< Take this object:

   135

   136

	RandomizedSpriteGroupCompareMode cmp_mode; ///< Check for these triggers:

   137

	byte triggers;

   138

	byte count;

   139

   140

	byte lowest_randbit; ///< Look for this in the per-object randomized bitmask:

   141

	byte num_groups; ///< must be power of 2

   142

   143

	const SpriteGroup **groups; ///< Take the group with appropriate index:

   144

};

   145

   146

   147

/* This contains a callback result. A failed callback has a value of

   148

 * CALLBACK_FAILED */

   149

struct CallbackResultSpriteGroup {

   150

	uint16 result;

   151

};

   152

   153

   154

/* A result sprite group returns the first SpriteID and the number of

   155

 * sprites in the set */

   156

struct ResultSpriteGroup {

   157

	SpriteID sprite;

   158

	byte num_sprites;

   159

};

   160

   161

struct TileLayoutSpriteGroup {

   162

	byte num_sprites; ///< Number of sprites in the spriteset, used for loading stages

   163

	struct DrawTileSprites *dts;

   164

};

   165

   166

struct IndustryProductionSpriteGroup {

   167

	uint8 version;

   168

	uint16 substract_input[3];

   169

	uint16 add_output[2];

   170

	uint8 again;

   171

};

   172

   173

/* List of different sprite group types */

   174

enum SpriteGroupType {

   175

	SGT_INVALID,

   176

	SGT_REAL,

   177

	SGT_DETERMINISTIC,

   178

	SGT_RANDOMIZED,

   179

	SGT_CALLBACK,

   180

	SGT_RESULT,

   181

	SGT_TILELAYOUT,

   182

	SGT_INDUSTRY_PRODUCTION,

   183

};

   184

   185

/* Common wrapper for all the different sprite group types */

   186

struct SpriteGroup {

   187

	SpriteGroupType type;

   188

   189

	union {

   190

		RealSpriteGroup real;

   191

		DeterministicSpriteGroup determ;

   192

		RandomizedSpriteGroup random;

   193

		CallbackResultSpriteGroup callback;

   194

		ResultSpriteGroup result;

   195

		TileLayoutSpriteGroup layout;

   196

		IndustryProductionSpriteGroup indprod;

   197

	} g;

   198

};

   199

   200

   201

SpriteGroup *AllocateSpriteGroup();

   202

void InitializeSpriteGroupPool();

   203

   204

   205

struct ResolverObject {

   206

	CallbackID callback;

   207

	uint32 callback_param1;

   208

	uint32 callback_param2;

   209

	bool procedure_call; ///< true if we are currently resolving a var 0x7E procedure result.

   210

   211

	byte trigger;

   212

	byte count;

   213

	uint32 last_value;

   214

	uint32 reseed;

   215

	VarSpriteGroupScope scope;

   216

   217

	bool info_view; ///< Indicates if the item is being drawn in an info window

   218

   219

	BaseStorageArray *psa; ///< The persistent storage array of this resolved object.

   220

   221

	union {

   222

		struct {

   223

			const struct Vehicle *self;

   224

			const struct Vehicle *parent;

   225

			EngineID self_type;

   226

		} vehicle;

   227

		struct {

   228

			TileIndex tile;

   229

		} canal;

   230

		struct {

   231

			TileIndex tile;

   232

			const struct Station *st;

   233

			const struct StationSpec *statspec;

   234

			CargoID cargo_type;

   235

		} station;

   236

		struct {

   237

			TileIndex tile;

   238

			Town *town;

   239

			HouseID house_id;

   240

		} house;

   241

		struct {

   242

			TileIndex tile;

   243

			Industry *ind;

   244

			IndustryGfx gfx;

   245

			IndustryType type;

   246

		} industry;

   247

		struct {

   248

			const struct CargoSpec *cs;

   249

		} cargo;

   250

		struct {

   251

			CargoID cargo_type;

   252

			uint8 default_selection;

   253

			IndustryType src_industry;

   254

			IndustryType dst_industry;

   255

			uint8 distance;

   256

			AIConstructionEvent event;

   257

			uint8 count;

   258

			uint8 station_size;

   259

		} generic;

   260

	} u;

   261

   262

	uint32 (*GetRandomBits)(const struct ResolverObject*);

   263

	uint32 (*GetTriggers)(const struct ResolverObject*);

   264

	void (*SetTriggers)(const struct ResolverObject*, int);

   265

	uint32 (*GetVariable)(const struct ResolverObject*, byte, byte, bool*);

   266

	const SpriteGroup *(*ResolveReal)(const struct ResolverObject*, const SpriteGroup*);

   267

   268

	ResolverObject() : procedure_call(false) { }

   269

};

   270

   271

   272

/* Base sprite group resolver */

   273

const SpriteGroup *Resolve(const SpriteGroup *group, ResolverObject *object);

   274

   275

   276

#endif /* NEWGRF_SPRITEGROUP_H */