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

}

    71

    72

    73

SpriteID GetCustomCargoSprite(const CargoSpec *cs)

    74

{

    75

	const SpriteGroup *group;

    76

	ResolverObject object;

    77

    78

	NewCargoResolver(&object, cs);

    79

    80

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

    81

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

    82

    83

	return group->g.result.sprite;

    84

}

    85

    86

    87

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

    88

{

    89

	ResolverObject object;

    90

	const SpriteGroup *group;

    91

    92

	NewCargoResolver(&object, cs);

    93

	object.callback = callback;

    94

	object.callback_param1 = param1;

    95

	object.callback_param2 = param2;

    96

    97

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

    98

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

    99

   100

	return group->g.callback.result;

   101

}

   102

   103

   104

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

   105

{

   106

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

   107

	if (grffile->grf_version < 7) {

   108

		if (!usebit) return cargo;

   109

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

   110

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

   111

	} else {

   112

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

   113

		 * then get the cargo ID for the label */

   114

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

   115

	}

   116

	return CT_INVALID;

   117

}

   118

   119

uint8 GetReverseCargoTranslation(CargoID cargo, const GRFFile *grffile)

   120

{

   121

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

   122

	const CargoSpec *cs = GetCargo(cargo);

   123

   124

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

   125

	 * then get the cargo ID for the label */

   126

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

   127

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

   128

	}

   129

   130

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

   131

	return cs->bitnum;;

   132

}