1

/* $Id$ */

     2

     3

/** @file newgrf_cargo.cpp Implementation of NewGRF cargoes. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "cargotype.h"

     9

#include "newgrf.h"

    10

#include "newgrf_callbacks.h"

    11

#include "newgrf_spritegroup.h"

    12

#include "newgrf_cargo.h"

    13

    14

    15

static uint32 CargoGetRandomBits(const ResolverObject *object)

    16

{

    17

	return 0;

    18

}

    19

    20

    21

static uint32 CargoGetTriggers(const ResolverObject *object)

    22

{

    23

	return 0;

    24

}

    25

    26

    27

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

    28

{

    29

	return;

    30

}

    31

    32

    33

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

    34

{

    35

	DEBUG(grf, 1, "Unhandled cargo property 0x%X", variable);

    36

    37

	*available = false;

    38

	return 0;

    39

}

    40

    41

    42

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

    43

{

    44

	/* Cargo action 2s should always have only 1 "loaded" state, but some

    45

	 * times things don't follow the spec... */

    46

	if (group->g.real.num_loaded > 0) return group->g.real.loaded[0];

    47

	if (group->g.real.num_loading > 0) return group->g.real.loading[0];

    48

    49

	return NULL;

    50

}

    51

    52

    53

static void NewCargoResolver(ResolverObject *res, const CargoSpec *cs)

    54

{

    55

	res->GetRandomBits = &CargoGetRandomBits;

    56

	res->GetTriggers   = &CargoGetTriggers;

    57

	res->SetTriggers   = &CargoSetTriggers;

    58

	res->GetVariable   = &CargoGetVariable;

    59

	res->ResolveReal   = &CargoResolveReal;

    60

    61

	res->u.cargo.cs = cs;

    62

    63

	res->callback        = CBID_NO_CALLBACK;

    64

	res->callback_param1 = 0;

    65

	res->callback_param2 = 0;

    66

	res->last_value      = 0;

    67

	res->trigger         = 0;

    68

	res->reseed          = 0;

    69

	res->count           = 0;

    70

	res->grffile         = cs->grffile;

    71

}

    72

    73

    74

SpriteID GetCustomCargoSprite(const CargoSpec *cs)

    75

{

    76

	const SpriteGroup *group;

    77

	ResolverObject object;

    78

    79

	NewCargoResolver(&object, cs);

    80

    81

	group = Resolve(cs->group, &object);

    82

	if (group == NULL || group->type != SGT_RESULT) return 0;

    83

    84

	return group->g.result.sprite;

    85

}

    86

    87

    88

uint16 GetCargoCallback(CallbackID callback, uint32 param1, uint32 param2, const CargoSpec *cs)

    89

{

    90

	ResolverObject object;

    91

	const SpriteGroup *group;

    92

    93

	NewCargoResolver(&object, cs);

    94

	object.callback = callback;

    95

	object.callback_param1 = param1;

    96

	object.callback_param2 = param2;

    97

    98

	group = Resolve(cs->group, &object);

    99

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

   100

   101

	return group->g.callback.result;

   102

}

   103

   104

   105

CargoID GetCargoTranslation(uint8 cargo, const GRFFile *grffile, bool usebit)

   106

{

   107

	/* Pre-version 7 uses the 'climate dependent' ID, i.e. cargo is the cargo ID */

   108

	if (grffile->grf_version < 7) {

   109

		if (!usebit) return cargo;

   110

		/* Else the cargo value is a 'climate independent' 'bitnum' */

   111

		if (HasBit(_cargo_mask, cargo)) return GetCargoIDByBitnum(cargo);

   112

	} else {

   113

		/* If the GRF contains a translation table... */

   114

		if (grffile->cargo_max > 0) {

   115

			/* ...and the cargo is in bounds, then get the cargo ID for

   116

			 * the label */

   117

			if (cargo < grffile->cargo_max) return GetCargoIDByLabel(grffile->cargo_list[cargo]);

   118

		} else {

   119

			/* Else the cargo value is a 'climate independent' 'bitnum' */

   120

			if (HasBit(_cargo_mask, cargo)) return GetCargoIDByBitnum(cargo);

   121

		}

   122

	}

   123

	return CT_INVALID;

   124

}

   125

   126

uint8 GetReverseCargoTranslation(CargoID cargo, const GRFFile *grffile)

   127

{

   128

	/* Note: All grf versions use CargoBit here. Pre-version 7 do NOT use the 'climate dependent' ID. */

   129

	const CargoSpec *cs = GetCargo(cargo);

   130

   131

	/* If the GRF contains a translation table (and the cargo is in the table)

   132

	 * then get the cargo ID for the label */

   133

	for (uint i = 0; i < grffile->cargo_max; i++) {

   134

		if (cs->label == grffile->cargo_list[i]) return i;

   135

	}

   136

   137

	/* No matching label was found, so we return the 'climate independent' 'bitnum' */

   138

	return cs->bitnum;;

   139

}