1

/* $Id$ */

     2

     3

/** @file newgrf_industrytiles.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "debug.h"

     9

#include "viewport_func.h"

    10

#include "landscape.h"

    11

#include "newgrf.h"

    12

#include "industry.h"

    13

#include "newgrf_commons.h"

    14

#include "newgrf_spritegroup.h"

    15

#include "newgrf_callbacks.h"

    16

#include "newgrf_industries.h"

    17

#include "newgrf_industrytiles.h"

    18

#include "newgrf_text.h"

    19

#include "industry_map.h"

    20

#include "clear_map.h"

    21

#include "sprite.h"

    22

#include "transparency.h"

    23

#include "functions.h"

    24

#include "town.h"

    25

#include "command_func.h"

    26

    27

#include "table/sprites.h"

    28

#include "table/strings.h"

    29

    30

static uint32 GetGRFParameter(IndustryGfx indtile_id, byte parameter)

    31

{

    32

	const IndustryTileSpec *indtspec = GetIndustryTileSpec(indtile_id);

    33

	const GRFFile *file = indtspec->grf_prop.grffile;

    34

    35

	if (parameter >= file->param_end) return 0;

    36

	return file->param[parameter];

    37

}

    38

    39

/**

    40

 * Based on newhouses equivalent, but adapted for newindustries

    41

 * @param parameter from callback.  It's in fact a pair of coordinates

    42

 * @param tile TileIndex from which the callback was initiated

    43

 * @param index of the industry been queried for

    44

 * @return a construction of bits obeying the newgrf format

    45

 */

    46

uint32 GetNearbyIndustryTileInformation(byte parameter, TileIndex tile, IndustryID index)

    47

{

    48

	byte tile_type;

    49

	bool is_same_industry;

    50

    51

	if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required

    52

	is_same_industry = (IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == index);

    53

	tile_type = GetTerrainType(tile) << 2 | (IsTileType(tile, MP_WATER) ? 1 : 0) << 1 | (is_same_industry ? 1 : 0);

    54

    55

	uint z;

    56

	Slope tileh = GetTileSlope(tile, &z);

    57

	return GetTileType(tile) << 24 | z << 16 | tile_type << 8 | tileh;

    58

}

    59

    60

/** This is the position of the tile relative to the northernmost tile of the industry.

    61

 * Format: 00yxYYXX

    62

 * Variable  Content

    63

 * x         the x offset from the northernmost tile

    64

 * XX        same, but stored in a byte instead of a nibble

    65

 * y         the y offset from the northernmost tile

    66

 * YY        same, but stored in a byte instead of a nibble

    67

 * @param tile TileIndex of the tile to evaluate

    68

 * @param ind_tile northernmost tile of the industry

    69

 */

    70

static uint32 GetRelativePosition(TileIndex tile, TileIndex ind_tile)

    71

{

    72

	byte x = TileX(tile) - TileX(ind_tile);

    73

	byte y = TileY(tile) - TileY(ind_tile);

    74

    75

	return ((y & 0xF) << 20) | ((x & 0xF) << 16) | (y << 8) | x;

    76

}

    77

    78

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

    79

{

    80

	const Industry *inds = object->u.industry.ind;

    81

	TileIndex tile       = object->u.industry.tile;

    82

    83

	if (object->scope == VSG_SCOPE_PARENT) {

    84

		return IndustryGetVariable(object, variable, parameter, available);

    85

	}

    86

    87

	switch (variable) {

    88

		 /* Construction state of the tile: a value between 0 and 3 */

    89

		case 0x40 : return (IsTileType(tile, MP_INDUSTRY)) ? GetIndustryConstructionStage(tile) : 0;

    90

    91

		case 0x41 : return GetTerrainType(tile);

    92

    93

		/* Current town zone of the tile in the nearest town */

    94

		case 0x42 : return GetTownRadiusGroup(ClosestTownFromTile(tile, (uint)-1), tile);

    95

    96

		/* Relative position */

    97

		case 0x43 : return GetRelativePosition(tile, inds->xy);

    98

    99

		/* Animation frame. Like house variable 46 but can contain anything 0..FF. */

   100

		case 0x44 : return (IsTileType(tile, MP_INDUSTRY)) ? GetIndustryAnimationState(tile) : 0;

   101

   102

		/* Land info of nearby tiles */

   103

		case 0x60 : return GetNearbyIndustryTileInformation(parameter, tile, inds == NULL ? (IndustryID)INVALID_INDUSTRY : inds->index);

   104

   105

		/* Animation stage of nearby tiles */

   106

		case 0x61 : {

   107

			tile = GetNearbyTile(parameter, tile);

   108

			if (IsTileType(tile, MP_INDUSTRY) && GetIndustryByTile(tile) == inds) {

   109

				return GetIndustryAnimationState(tile);

   110

			}

   111

			return 0xFFFFFFFF;

   112

		}

   113

   114

		/* Get industry tile ID at offset */

   115

		case 0x62 : return GetIndustryIDAtOffset(GetNearbyTile(parameter, tile), inds);

   116

   117

		/* Read GRF parameter */

   118

		case 0x7F: return GetGRFParameter(GetIndustryGfx(tile), parameter);

   119

	}

   120

   121

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

   122

   123

	*available = false;

   124

	return (uint32)-1;

   125

}

   126

   127

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

   128

{

   129

	/* IndustryTile do not have 'real' groups.  Or do they?? */

   130

	return NULL;

   131

}

   132

   133

static uint32 IndustryTileGetRandomBits(const ResolverObject *object)

   134

{

   135

	const TileIndex tile = object->u.industry.tile;

   136

	if (tile == INVALID_TILE || !IsTileType(tile, MP_INDUSTRY)) return 0;

   137

	return (object->scope == VSG_SCOPE_SELF) ? GetIndustryRandomBits(tile) : GetIndustryByTile(tile)->random;

   138

}

   139

   140

static uint32 IndustryTileGetTriggers(const ResolverObject *object)

   141

{

   142

	const TileIndex tile = object->u.industry.tile;

   143

	if (tile == INVALID_TILE || !IsTileType(tile, MP_INDUSTRY)) return 0;

   144

	return (object->scope == VSG_SCOPE_SELF) ? GetIndustryTriggers(tile) : GetIndustryByTile(tile)->random_triggers;

   145

}

   146

   147

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

   148

{

   149

	const TileIndex tile = object->u.industry.tile;

   150

	if (tile == INVALID_TILE || !IsTileType(tile, MP_INDUSTRY)) return;

   151

   152

	if (object->scope == VSG_SCOPE_SELF) {

   153

		SetIndustryTriggers(tile, triggers);

   154

	} else {

   155

		GetIndustryByTile(tile)->random_triggers = triggers;

   156

	}

   157

}

   158

   159

static void NewIndustryTileResolver(ResolverObject *res, IndustryGfx gfx, TileIndex tile, Industry *indus)

   160

{

   161

	res->GetRandomBits = IndustryTileGetRandomBits;

   162

	res->GetTriggers   = IndustryTileGetTriggers;

   163

	res->SetTriggers   = IndustryTileSetTriggers;

   164

	res->GetVariable   = IndustryTileGetVariable;

   165

	res->ResolveReal   = IndustryTileResolveReal;

   166

   167

	res->psa             = &indus->psa;

   168

	res->u.industry.tile = tile;

   169

	res->u.industry.ind  = indus;

   170

	res->u.industry.gfx  = gfx;

   171

	res->u.industry.type = indus->type;

   172

   173

	res->callback        = CBID_NO_CALLBACK;

   174

	res->callback_param1 = 0;

   175

	res->callback_param2 = 0;

   176

	res->last_value      = 0;

   177

	res->trigger         = 0;

   178

	res->reseed          = 0;

   179

}

   180

   181

void IndustryDrawTileLayout(const TileInfo *ti, const SpriteGroup *group, byte rnd_color, byte stage, IndustryGfx gfx)

   182

{

   183

	const DrawTileSprites *dts = group->g.layout.dts;

   184

	const DrawTileSeqStruct *dtss;

   185

   186

	SpriteID image = dts->ground_sprite;

   187

	SpriteID pal   = dts->ground_pal;

   188

   189

	if (IS_CUSTOM_SPRITE(image)) image += stage;

   190

   191

	if (GB(image, 0, SPRITE_WIDTH) != 0) DrawGroundSprite(image, pal);

   192

   193

	foreach_draw_tile_seq(dtss, dts->seq) {

   194

		if (GB(dtss->image, 0, SPRITE_WIDTH) == 0) continue;

   195

   196

		image = dtss->image;

   197

		pal   = dtss->pal;

   198

   199

		if (IS_CUSTOM_SPRITE(image)) image += stage;

   200

   201

		if (HasBit(image, PALETTE_MODIFIER_COLOR)) {

   202

			if (pal == 0) {

   203

				pal = GENERAL_SPRITE_COLOR(rnd_color);

   204

			}

   205

		} else {

   206

			pal = PAL_NONE;

   207

		}

   208

   209

		if ((byte)dtss->delta_z != 0x80) {

   210

			AddSortableSpriteToDraw(

   211

				image, pal,

   212

				ti->x + dtss->delta_x, ti->y + dtss->delta_y,

   213

				dtss->size_x, dtss->size_y,

   214

				dtss->size_z, ti->z + dtss->delta_z,

   215

				!HasBit(image, SPRITE_MODIFIER_OPAQUE) && IsTransparencySet(TO_INDUSTRIES)

   216

			);

   217

		} else {

   218

			AddChildSpriteScreen(image, pal, (byte)dtss->delta_x, (byte)dtss->delta_y, IsTransparencySet(TO_INDUSTRIES));

   219

		}

   220

	}

   221

}

   222

   223

uint16 GetIndustryTileCallback(CallbackID callback, uint32 param1, uint32 param2, IndustryGfx gfx_id, Industry *industry, TileIndex tile)

   224

{

   225

	ResolverObject object;

   226

	const SpriteGroup *group;

   227

   228

	NewIndustryTileResolver(&object, gfx_id, tile, industry);

   229

	object.callback = callback;

   230

	object.callback_param1 = param1;

   231

	object.callback_param2 = param2;

   232

   233

	group = Resolve(GetIndustryTileSpec(gfx_id)->grf_prop.spritegroup, &object);

   234

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

   235

   236

	return group->g.callback.result;

   237

}

   238

   239

bool DrawNewIndustryTile(TileInfo *ti, Industry *i, IndustryGfx gfx, const IndustryTileSpec *inds)

   240

{

   241

	const SpriteGroup *group;

   242

	ResolverObject object;

   243

   244

	if (ti->tileh != SLOPE_FLAT) {

   245

		bool draw_old_one = true;

   246

		if (HasBit(inds->callback_flags, CBM_INDT_DRAW_FOUNDATIONS)) {

   247

			/* Called to determine the type (if any) of foundation to draw for industry tile */

   248

			uint32 callback_res = GetIndustryTileCallback(CBID_INDUSTRY_DRAW_FOUNDATIONS, 0, 0, gfx, i, ti->tile);

   249

			draw_old_one = callback_res != 0;

   250

		}

   251

   252

		if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED);

   253

	}

   254

   255

	NewIndustryTileResolver(&object, gfx, ti->tile, i);

   256

   257

	group = Resolve(inds->grf_prop.spritegroup, &object);

   258

	if (group == NULL || group->type != SGT_TILELAYOUT) {

   259

		return false;

   260

	} else {

   261

		/* Limit the building stage to the number of stages supplied. */

   262

		byte stage = GetIndustryConstructionStage(ti->tile);

   263

		stage = Clamp(stage - 4 + group->g.layout.num_sprites, 0, group->g.layout.num_sprites - 1);

   264

		IndustryDrawTileLayout(ti, group, i->random_color, stage, gfx);

   265

		return true;

   266

	}

   267

}

   268

   269

extern bool IsSlopeRefused(Slope current, Slope refused);

   270

   271

bool PerformIndustryTileSlopeCheck(TileIndex ind_base_tile, TileIndex ind_tile, const IndustryTileSpec *its, IndustryType type, IndustryGfx gfx, uint itspec_index)

   272

{

   273

	Industry ind;

   274

	ind.index = INVALID_INDUSTRY;

   275

	ind.xy = ind_base_tile;

   276

	ind.width = 0;

   277

	ind.type = type;

   278

   279

	uint16 callback_res = GetIndustryTileCallback(CBID_INDTILE_SHAPE_CHECK, 0, itspec_index, gfx, &ind, ind_tile);

   280

	if (callback_res == CALLBACK_FAILED) {

   281

		return !IsSlopeRefused(GetTileSlope(ind_tile, NULL), its->slopes_refused);

   282

	}

   283

	if (its->grf_prop.grffile->grf_version < 7) {

   284

		return callback_res != 0;

   285

	}

   286

   287

	/* Copy some parameters from the registers to the error message text ref. stack */

   288

	SwitchToErrorRefStack();

   289

	PrepareTextRefStackUsage(4);

   290

	SwitchToNormalRefStack();

   291

   292

	switch (callback_res) {

   293

		case 0x400: return true;

   294

		case 0x401: _error_message = STR_0239_SITE_UNSUITABLE;                 return false;

   295

		case 0x402: _error_message = STR_0317_CAN_ONLY_BE_BUILT_IN_RAINFOREST; return false;

   296

		case 0x403: _error_message = STR_0318_CAN_ONLY_BE_BUILT_IN_DESERT;     return false;

   297

		default: _error_message = GetGRFStringID(its->grf_prop.grffile->grfid, 0xD000 + callback_res); return false;

   298

	}

   299

}

   300

   301

void AnimateNewIndustryTile(TileIndex tile)

   302

{

   303

	Industry *ind = GetIndustryByTile(tile);

   304

	IndustryGfx gfx = GetIndustryGfx(tile);

   305

	const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);

   306

	byte animation_speed = itspec->animation_speed;

   307

   308

	if (HasBit(itspec->callback_flags, CBM_INDT_ANIM_SPEED)) {

   309

		uint16 callback_res = GetIndustryTileCallback(CBID_INDTILE_ANIMATION_SPEED, 0, 0, gfx, ind, tile);

   310

		if (callback_res != CALLBACK_FAILED) animation_speed = Clamp(callback_res & 0xFF, 0, 16);

   311

	}

   312

   313

	/* An animation speed of 2 means the animation frame changes 4 ticks, and

   314

	 * increasing this value by one doubles the wait. 0 is the minimum value

   315

	 * allowed for animation_speed, which corresponds to 30ms, and 16 is the

   316

	 * maximum, corresponding to around 33 minutes. */

   317

	if ((_tick_counter % (1 << animation_speed)) != 0) return;

   318

   319

	bool frame_set_by_callback = false;

   320

	byte frame = GetIndustryAnimationState(tile);

   321

	uint16 num_frames = GB(itspec->animation_info, 0, 8);

   322

   323

	if (HasBit(itspec->callback_flags, CBM_INDT_ANIM_NEXT_FRAME)) {

   324

		uint16 callback_res = GetIndustryTileCallback(CBID_INDTILE_ANIM_NEXT_FRAME, HasBit(itspec->animation_special_flags, 0) ? Random() : 0, 0, gfx, ind, tile);

   325

   326

		if (callback_res != CALLBACK_FAILED) {

   327

			frame_set_by_callback = true;

   328

   329

			switch (callback_res & 0xFF) {

   330

				case 0xFF:

   331

					DeleteAnimatedTile(tile);

   332

					break;

   333

				case 0xFE:

   334

					/* Carry on as normal. */

   335

					frame_set_by_callback = false;

   336

					break;

   337

				default:

   338

					frame = callback_res & 0xFF;

   339

					break;

   340

			}

   341

		}

   342

	}

   343

   344

	if (!frame_set_by_callback) {

   345

		if (frame < num_frames) {

   346

			frame++;

   347

		} else if (frame == num_frames && GB(itspec->animation_info, 8, 8) == 1) {

   348

			/* This animation loops, so start again from the beginning */

   349

			frame = 0;

   350

		} else {

   351

			/* This animation doesn't loop, so stay here */

   352

			DeleteAnimatedTile(tile);

   353

		}

   354

	}

   355

   356

	SetIndustryAnimationState(tile, frame);

   357

	MarkTileDirtyByTile(tile);

   358

}

   359

   360

static void ChangeIndustryTileAnimationFrame(TileIndex tile, IndustryAnimationTrigger iat, uint32 random_bits, IndustryGfx gfx, Industry *ind)

   361

{

   362

	uint16 callback_res = GetIndustryTileCallback(CBID_INDTILE_ANIM_START_STOP, random_bits, iat, gfx, ind, tile);

   363

	if (callback_res == CALLBACK_FAILED) return;

   364

   365

	switch (callback_res & 0xFF) {

   366

		case 0xFD: /* Do nothing. */         break;

   367

		case 0xFE: AddAnimatedTile(tile);    break;

   368

		case 0xFF: DeleteAnimatedTile(tile); break;

   369

		default:

   370

			SetIndustryAnimationState(tile, callback_res & 0xFF);

   371

			AddAnimatedTile(tile);

   372

			break;

   373

	}

   374

}

   375

   376

bool StartStopIndustryTileAnimation(TileIndex tile, IndustryAnimationTrigger iat, uint32 random)

   377

{

   378

	IndustryGfx gfx = GetIndustryGfx(tile);

   379

	const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);

   380

   381

	if (!HasBit(itspec->animation_triggers, iat)) return false;

   382

   383

	Industry *ind = GetIndustryByTile(tile);

   384

	ChangeIndustryTileAnimationFrame(tile, iat, random, gfx, ind);

   385

	return true;

   386

}

   387

   388

bool StartStopIndustryTileAnimation(const Industry *ind, IndustryAnimationTrigger iat)

   389

{

   390

	bool ret = true;

   391

	uint32 random = Random();

   392

	BEGIN_TILE_LOOP(tile, ind->width, ind->height, ind->xy)

   393

		if (IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == ind->index) {

   394

			if (StartStopIndustryTileAnimation(tile, iat, random)) {

   395

				SB(random, 0, 16, Random());

   396

			} else {

   397

				ret = false;

   398

			}

   399

		}

   400

	END_TILE_LOOP(tile, ind->width, ind->height, ind->xy)

   401

   402

	return ret;

   403

}

   404

   405

static void DoTriggerIndustryTile(TileIndex tile, IndustryTileTrigger trigger, Industry *ind)

   406

{

   407

	ResolverObject object;

   408

   409

	IndustryGfx gfx = GetIndustryGfx(tile);

   410

	const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);

   411

   412

	NewIndustryTileResolver(&object, gfx, tile, ind);

   413

   414

	object.callback = CBID_RANDOM_TRIGGER;

   415

	object.trigger = trigger;

   416

   417

	const SpriteGroup *group = Resolve(itspec->grf_prop.spritegroup, &object);

   418

	if (group == NULL) return;

   419

   420

	byte new_random_bits = Random();

   421

	byte random_bits = GetIndustryRandomBits(tile);

   422

	random_bits &= ~object.reseed;

   423

	random_bits |= new_random_bits & object.reseed;

   424

	SetIndustryRandomBits(tile, random_bits);

   425

}

   426

   427

void TriggerIndustryTile(TileIndex tile, IndustryTileTrigger trigger)

   428

{

   429

	DoTriggerIndustryTile(tile, trigger, GetIndustryByTile(tile));

   430

}

   431

   432

void TriggerIndustry(Industry *ind, IndustryTileTrigger trigger)

   433

{

   434

	BEGIN_TILE_LOOP(tile, ind->width, ind->height, ind->xy)

   435

		if (IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == ind->index) {

   436

			DoTriggerIndustryTile(tile, trigger, ind);

   437

		}

   438

	END_TILE_LOOP(tile, ind->width, ind->height, ind->xy)

   439

}