1

/* $Id$ */

     2

     3

/** @file newgrf_commons.h This file simplyfies and embeds a common mechanism of

     4

 * loading/saving and mapping of grf entities.

     5

 */

     6

     7

#ifndef NEWGRF_COMMONS_H

     8

#define NEWGRF_COMMONS_H

     9

    10

#include "core/bitmath_func.hpp"

    11

    12

#include "table/sprites.h"

    13

    14

/**

    15

 * Maps an entity id stored on the map to a GRF file.

    16

 * Entities are objects used ingame (houses, industries, industry tiles) for

    17

 * which we need to correlate the ids from the grf files with the ones in the

    18

 * the savegames themselves.

    19

 * An array of EntityIDMapping structs is saved with the savegame so

    20

 * that those GRFs can be loaded in a different order, or removed safely. The

    21

 * index in the array is the entity's ID stored on the map.

    22

 *

    23

 * The substitute ID is the ID of an original entity that should be used instead

    24

 * if the GRF containing the new entity is not available.

    25

 */

    26

struct EntityIDMapping {

    27

	uint32 grfid;          ///< The GRF ID of the file the entity belongs to

    28

	uint8  entity_id;      ///< The entity ID within the GRF file

    29

	uint8  substitute_id;  ///< The (original) entity ID to use if this GRF is not available

    30

};

    31

    32

class OverrideManagerBase {

    33

protected:

    34

	uint16 *entity_overrides;

    35

	uint32 *grfid_overrides;

    36

    37

	uint16 max_offset;       ///< what is the length of the original entity's array of specs

    38

	uint16 max_new_entities; ///< what is the amount of entities, old and new summed

    39

    40

	uint16 invalid_ID;       ///< ID used to dected invalid entities;

    41

	virtual bool CheckValidNewID(uint16 testid) { return true; }

    42

    43

public:

    44

	EntityIDMapping *mapping_ID; ///< mapping of ids from grf files.  Public out of convenience

    45

    46

	OverrideManagerBase(uint16 offset, uint16 maximum, uint16 invalid);

    47

	virtual ~OverrideManagerBase();

    48

    49

	void ResetOverride();

    50

	void ResetMapping();

    51

    52

	void Add(uint8 local_id, uint32 grfid, uint entity_type);

    53

	virtual uint16 AddEntityID(byte grf_local_id, uint32 grfid, byte substitute_id);

    54

    55

	uint16 GetSubstituteID(byte entity_id);

    56

	virtual uint16 GetID(uint8 grf_local_id, uint32 grfid);

    57

    58

	inline uint16 GetMaxMapping() { return max_new_entities; }

    59

	inline uint16 GetMaxOffset() { return max_offset; }

    60

};

    61

    62

    63

struct HouseSpec;

    64

class HouseOverrideManager : public OverrideManagerBase {

    65

public:

    66

	HouseOverrideManager(uint16 offset, uint16 maximum, uint16 invalid) :

    67

			OverrideManagerBase(offset, maximum, invalid) {}

    68

	void SetEntitySpec(const HouseSpec *hs);

    69

};

    70

    71

    72

struct IndustrySpec;

    73

class IndustryOverrideManager : public OverrideManagerBase {

    74

public:

    75

	IndustryOverrideManager(uint16 offset, uint16 maximum, uint16 invalid) :

    76

			OverrideManagerBase(offset, maximum, invalid) {}

    77

    78

	virtual uint16 AddEntityID(byte grf_local_id, uint32 grfid, byte substitute_id);

    79

	virtual uint16 GetID(uint8 grf_local_id, uint32 grfid);

    80

	void SetEntitySpec(IndustrySpec *inds);

    81

};

    82

    83

    84

struct IndustryTileSpec;

    85

class IndustryTileOverrideManager : public OverrideManagerBase {

    86

protected:

    87

	virtual bool CheckValidNewID(uint16 testid) { return testid != 0xFF; }

    88

public:

    89

	IndustryTileOverrideManager(uint16 offset, uint16 maximum, uint16 invalid) :

    90

			OverrideManagerBase(offset, maximum, invalid) {}

    91

    92

	void SetEntitySpec(const IndustryTileSpec *indts);

    93

};

    94

    95

extern HouseOverrideManager _house_mngr;

    96

extern IndustryOverrideManager _industry_mngr;

    97

extern IndustryTileOverrideManager _industile_mngr;

    98

    99

uint32 GetTerrainType(TileIndex tile);

   100

TileIndex GetNearbyTile(byte parameter, TileIndex tile);

   101

uint32 GetNearbyTileInformation(TileIndex tile);

   102

   103

/**

   104

 * Applies PALETTE_MODIFIER_TRANSPARENT and PALETTE_MODIFIER_COLOR to a palette entry of a sprite layout entry

   105

 * @Note for ground sprites use #GroundSpritePaletteTransform

   106

 * @Note Not useable for OTTD internal spritelayouts from table/xxx_land.h as PALETTE_MODIFIER_TRANSPARENT is only set

   107

 *       when to use the default palette.

   108

 *

   109

 * @param image The sprite to draw

   110

 * @param pal The palette from the sprite layout

   111

 * @param default_pal The default recolour sprite to use (typically company color resp. random industry/house color)

   112

 * @return The palette to use

   113

 */

   114

static inline SpriteID SpriteLayoutPaletteTransform(SpriteID image, SpriteID pal, SpriteID default_pal)

   115

{

   116

	if (HasBit(image, PALETTE_MODIFIER_TRANSPARENT) || HasBit(image, PALETTE_MODIFIER_COLOR)) {

   117

		return (pal != 0 ? pal : default_pal);

   118

	} else {

   119

		return PAL_NONE;

   120

	}

   121

}

   122

   123

/**

   124

 * Applies PALETTE_MODIFIER_COLOR to a palette entry of a ground sprite

   125

 * @Note Not useable for OTTD internal spritelayouts from table/xxx_land.h as PALETTE_MODIFIER_TRANSPARENT is only set

   126

 *       when to use the default palette.

   127

 *

   128

 * @param image The sprite to draw

   129

 * @param pal The palette from the sprite layout

   130

 * @param default_pal The default recolour sprite to use (typically company color resp. random industry/house color)

   131

 * @return The palette to use

   132

 */

   133

static inline SpriteID GroundSpritePaletteTransform(SpriteID image, SpriteID pal, SpriteID default_pal)

   134

{

   135

	if (HasBit(image, PALETTE_MODIFIER_COLOR)) {

   136

		return (pal != 0 ? pal : default_pal);

   137

	} else {

   138

		return PAL_NONE;

   139

	}

   140

}

   141

   142

#endif /* NEWGRF_COMMONS_H */