1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "cargotype.h"

     7

#include "newgrf.h"

     8

#include "newgrf_callbacks.h"

     9

#include "newgrf_spritegroup.h"

    10

#include "newgrf_cargo.h"

    11

    12

    13

static uint32 CargoGetRandomBits(const ResolverObject *object)

    14

{

    15

	return 0;

    16

}

    17

    18

    19

static uint32 CargoGetTriggers(const ResolverObject *object)

    20

{

    21

	return 0;

    22

}

    23

    24

    25

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

    26

{

    27

	return;

    28

}

    29

    30

    31

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

    32

{

    33

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

    34

    35

	*available = false;

    36

	return 0;

    37

}

    38

    39

    40

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

    41

{

    42

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

    43

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

    44

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

    45

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

    46

    47

	return NULL;

    48

}

    49

    50

    51

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

    52

{

    53

	res->GetRandomBits = &CargoGetRandomBits;

    54

	res->GetTriggers   = &CargoGetTriggers;

    55

	res->SetTriggers   = &CargoSetTriggers;

    56

	res->GetVariable   = &CargoGetVariable;

    57

	res->ResolveReal   = &CargoResolveReal;

    58

    59

	res->u.cargo.cs = cs;

    60

    61

	res->callback        = CBID_NO_CALLBACK;

    62

	res->callback_param1 = 0;

    63

	res->callback_param2 = 0;

    64

	res->last_value      = 0;

    65

	res->trigger         = 0;

    66

	res->reseed          = 0;

    67

	res->count           = 0;

    68

}

    69

    70

    71

SpriteID GetCustomCargoSprite(const CargoSpec *cs)

    72

{

    73

	const SpriteGroup *group;

    74

	ResolverObject object;

    75

    76

	NewCargoResolver(&object, cs);

    77

    78

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

    79

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

    80

    81

	return group->g.result.sprite;

    82

}

    83

    84

    85

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

    86

{

    87

	ResolverObject object;

    88

	const SpriteGroup *group;

    89

    90

	NewCargoResolver(&object, cs);

    91

	object.callback = callback;

    92

	object.callback_param1 = param1;

    93

	object.callback_param2 = param2;

    94

    95

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

    96

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

    97

    98

	return group->g.callback.result;

    99

}

   100

   101

   102

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

   103

{

   104

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

   105

	if (grffile->grf_version < 7) {

   106

		if (!usebit) return cargo;

   107

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

   108

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

   109

	} else {

   110

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

   111

		 * then get the cargo ID for the label */

   112

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

   113

	}

   114

	return CT_INVALID;

   115

}

   116

   117

uint8 GetReverseCargoTranslation(CargoID cargo, const GRFFile *grffile)

   118

{

   119

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

   120

	const CargoSpec *cs = GetCargo(cargo);

   121

   122

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

   123

	 * then get the cargo ID for the label */

   124

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

   125

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

   126

	}

   127

   128

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

   129

	return cs->bitnum;;

   130

}