1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "command.h"

     4

#include "viewport.h"

     5

#include "player.h"

     6

#include "gui.h"

     7

#include "economy.h"

     8

#include "town.h"

     9

    10

typedef struct DrawTileUnmovableStruct {

    11

	uint16 image;

    12

	byte subcoord_x;

    13

	byte subcoord_y;

    14

	byte width;

    15

	byte height;

    16

	byte z_size;

    17

	byte unused;

    18

} DrawTileUnmovableStruct;

    19

    20

typedef struct DrawTileSeqStruct {

    21

	int8 delta_x;

    22

	int8 delta_y;

    23

	int8 delta_z;

    24

	byte width,height;

    25

	byte unk;

    26

	SpriteID image;

    27

} DrawTileSeqStruct;

    28

    29

#include "table/unmovable_land.h"

    30

    31

static void DrawTile_Unmovable(TileInfo *ti)

    32

{

    33

	uint32 image, ormod;

    34

    35

	if (!(ti->map5 & 0x80)) {

    36

		if (ti->map5 == 2) {

    37

    38

			// statue

    39

			DrawGroundSprite(0x58C);

    40

    41

			image = PLAYER_SPRITE_COLOR(_map_owner[ti->tile]);

    42

			image += 0x8A48;

    43

			if (!(_display_opt & DO_TRANS_BUILDINGS))

    44

				image = (image & 0x3FFF) | 0x3224000;

    45

			AddSortableSpriteToDraw(image, ti->x, ti->y, 16, 16, 25, ti->z);

    46

		} else if (ti->map5 == 3) {

    47

    48

			// "owned by" sign

    49

			DrawClearLandTile(ti, 0);

    50

    51

			AddSortableSpriteToDraw(

    52

				PLAYER_SPRITE_COLOR(_map_owner[ti->tile]) + 0x92B6,

    53

				ti->x+8, ti->y+8,

    54

				1, 1, 

    55

				10, 

    56

				GetSlopeZ(ti->x+8, ti->y+8)

    57

			);

    58

		} else {

    59

			// lighthouse or transmitter

    60

    61

			const DrawTileUnmovableStruct *dtus;

    62

    63

			if (ti->tileh) DrawFoundation(ti, ti->tileh);

    64

			DrawClearLandTile(ti, 2);

    65

    66

			dtus = &_draw_tile_unmovable_data[ti->map5];		

    67

    68

			image = dtus->image;

    69

			if (!(_display_opt & DO_TRANS_BUILDINGS))

    70

				image = (image & 0x3FFF) | 0x3224000;

    71

    72

			AddSortableSpriteToDraw(image, 

    73

				ti->x | dtus->subcoord_x,

    74

				ti->y | dtus->subcoord_y,

    75

				dtus->width, dtus->height,

    76

				dtus->z_size, ti->z);

    77

		}

    78

	} else {

    79

		const DrawTileSeqStruct *dtss;

    80

		const byte *t;

    81

    82

		if (ti->tileh) DrawFoundation(ti, ti->tileh);

    83

    84

		ormod = PLAYER_SPRITE_COLOR(_map_owner[ti->tile]);

    85

    86

		t = _unmovable_display_datas[ti->map5 & 0x7F];

    87

		DrawGroundSprite(*(uint16*)t | ormod);

    88

    89

		t += sizeof(uint16);

    90

    91

		for(dtss = (DrawTileSeqStruct *)t; (byte)dtss->delta_x != 0x80; dtss++) {

    92

			image =	dtss->image;

    93

			if (_display_opt & DO_TRANS_BUILDINGS) {

    94

				image |= ormod;

    95

			} else {

    96

				image = (image & 0x3FFF) | 0x03224000;

    97

			}

    98

			AddSortableSpriteToDraw(image, ti->x + dtss->delta_x, ti->y + dtss->delta_y,

    99

				dtss->width, dtss->height, dtss->unk, ti->z + dtss->delta_z);

   100

		}

   101

	}

   102

}

   103

   104

static uint GetSlopeZ_Unmovable(TileInfo *ti) 

   105

{

   106

	return GetPartialZ(ti->x&0xF, ti->y&0xF, ti->tileh) + ti->z;

   107

}

   108

   109

static uint GetSlopeTileh_Unmovable(TileInfo *ti) 

   110

{

   111

	return 0;

   112

}

   113

   114

static int32 ClearTile_Unmovable(uint tile, byte flags)

   115

{

   116

	byte m5 = _map5[tile];

   117

   118

	if (m5 & 0x80) {

   119

		if (_current_player == OWNER_WATER) 

   120

			return DoCommandByTile(tile, OWNER_WATER, 0, DC_EXEC, CMD_DESTROY_COMPANY_HQ);

   121

		return_cmd_error(STR_5804_COMPANY_HEADQUARTERS_IN);

   122

	}	

   123

   124

	if (m5 == 3)	// company owned land

   125

		return DoCommandByTile(tile, 0, 0, flags, CMD_SELL_LAND_AREA);

   126

   127

	// checks if you're allowed to remove unmovable things

   128

	if (_game_mode != GM_EDITOR && _current_player != OWNER_WATER && ((flags & DC_AUTO || !_cheats.magic_bulldozer.value)) )

   129

		return_cmd_error(STR_5800_OBJECT_IN_THE_WAY);

   130

   131

	if (flags & DC_EXEC) {	

   132

		DoClearSquare(tile);

   133

	}

   134

   135

	return 0;

   136

}

   137

   138

static void GetAcceptedCargo_Unmovable(uint tile, AcceptedCargo *ac)

   139

{

   140

	byte m5 = _map5[tile];

   141

	uint level; // HQ level (depends on company performance) in the range 1..5.

   142

   143

	if (!(m5 & 0x80)) {

   144

		/* not used */

   145

		return;

   146

	}

   147

   148

	/* HQ accepts passenger and mail; but we have to divide the values

   149

	 * between 4 tiles it occupies! */

   150

   151

	level = (m5 & ~0x80) / 4 + 1;

   152

   153

	// Top town building generates 10, so to make HQ interesting, the top

   154

	// type makes 20.

   155

	ac->type_1 = CT_PASSENGERS;

   156

	ac->amount_1 = level;

   157

	if (!ac->amount_1) ac->amount_1 = 1;

   158

   159

	// Top town building generates 4, HQ can make up to 8. The

   160

	// proportion passengers:mail is different because such a huge

   161

	// commercial building generates unusually high amount of mail

   162

	// correspondence per physical visitor.

   163

	ac->type_2 = CT_MAIL;

   164

	ac->amount_2 = level / 2;

   165

	if (!ac->amount_2) ac->amount_2 = 1;

   166

}

   167

   168

static const StringID _unmovable_tile_str[] = {

   169

	STR_5803_COMPANY_HEADQUARTERS,

   170

	STR_5801_TRANSMITTER,

   171

	STR_5802_LIGHTHOUSE,

   172

	STR_2016_STATUE,

   173

	STR_5805_COMPANY_OWNED_LAND,

   174

};	

   175

   176

static void GetTileDesc_Unmovable(uint tile, TileDesc *td)

   177

{

   178

	int i = _map5[tile];

   179

	if (i & 0x80) i = -1;

   180

	td->str = _unmovable_tile_str[i + 1];

   181

	td->owner = _map_owner[tile];

   182

}

   183

   184

static void AnimateTile_Unmovable(uint tile)

   185

{

   186

	/* not used */

   187

}

   188

   189

static void TileLoop_Unmovable(uint tile)

   190

{

   191

	byte m5 = _map5[tile];

   192

	byte level; // HQ level (depends on company performance) in the range 1..5.

   193

	uint32 r;

   194

   195

	if (!(m5 & 0x80)) {

   196

		/* not used */

   197

		return;

   198

	}

   199

   200

	/* HQ accepts passenger and mail; but we have to divide the values

   201

	 * between 4 tiles it occupies! */

   202

   203

	level = (m5 & ~0x80) / 4 + 1;

   204

	assert(level < 6);

   205

   206

	r = Random();

   207

	// Top town buildings generate 250, so the top HQ type makes 256.

   208

	if ((byte) r < (256 / 4 /  (6 - level))) {

   209

		uint amt = ((byte) r >> 3) / 4 + 1;

   210

		if (_economy.fluct <= 0) amt = (amt + 1) >> 1;

   211

		MoveGoodsToStation(tile, 2, 2, CT_PASSENGERS, amt);

   212

	}

   213

   214

	r >>= 8;

   215

	// Top town building generates 90, HQ can make up to 196. The

   216

	// proportion passengers:mail is about the same as in the acceptance

   217

	// equations.

   218

	if ((byte) r < (196 / 4 / (6 - level))) {

   219

		uint amt = ((byte) r >> 3) / 4 + 1;

   220

		if (_economy.fluct <= 0) amt = (amt + 1) >> 1;

   221

		MoveGoodsToStation(tile, 2, 2, CT_MAIL, amt);

   222

	}

   223

}

   224

   225

   227

{

   228

	return 0;

   229

}

   230

   231

static void ClickTile_Unmovable(uint tile)

   232

{

   233

	if (_map5[tile] & 0x80) {

   234

		ShowPlayerCompany(_map_owner[tile]);

   235

	}

   236

}

   237

   238

static const TileIndexDiff _tile_add[4] = {

   239

	TILE_XY(1,0),

   240

	TILE_XY(0,1),

   241

	TILE_XY(-1,0),

   242

	TILE_XY(0,-1),

   243

};

   244

   245

/* checks, if a radio tower is within a 9x9 tile square around tile */

   246

bool checkRadioTowerNearby(uint tile)

   247

{

   248

	uint tile_s;

   249

   250

	tile_s = TILE_XY( (int) GET_TILE_X(tile)-4, (int) GET_TILE_Y(tile)-4 );

   251

   252

	BEGIN_TILE_LOOP(tile, 9, 9, tile_s)

   253

		// already a radio tower here?

   254

		if (IS_TILETYPE(tile, MP_UNMOVABLE) && _map5[tile] == 0)

   255

			return false;

   256

	END_TILE_LOOP(tile, 9, 9, tile_s)

   257

	return true;

   258

}

   259

   260

void GenerateUnmovables()

   261

{

   262

	int i,j;

   263

	uint tile;

   264

	uint32 r;

   265

	int dir;

   266

	int h;

   267

   268

	if (_opt.landscape == LT_CANDY)

   269

		return;

   270

   271

	/* add radio tower */

   272

	i = 1000;

   273

	j = 40; // limit of 40 radio towers per world.

   274

	do {

   275

		r = Random();

   276

		tile = r % (TILES_X*TILES_Y);

   277

//		TILE_MASK seems to be not working correctly. Radio masts accumulate in one area.

   278

//		tile = TILE_MASK(r);

   279

		if (IS_TILETYPE(tile, MP_CLEAR) && GetTileSlope(tile, &h) == 0 && h >= 32) {

   280

			if(!checkRadioTowerNearby(tile))

   281

				continue;

   282

			_map_type_and_height[tile] |= MP_UNMOVABLE << 4;

   283

			_map5[tile] = 0;

   284

			_map_owner[tile] = OWNER_NONE;

   285

			if (--j == 0)

   286

				break;

   287

		}

   288

	} while (--i);

   289

   290

	if (_opt.landscape == LT_DESERT)

   291

		return;

   292

   293

	/* add lighthouses */

   294

	i = (Random()&3) + 7;

   295

	do {

   296

restart:

   297

		r = Random();

   298

		dir = r >> 30;

   299

		r = r%((dir==0 || dir== 2)?TILE_Y_MAX:TILE_X_MAX);

   300

		tile = 

   301

          (dir==0)?TILE_XY(0,r):0 +             // left

   302

          (dir==1)?TILE_XY(r,0):0 +             // top

   303

          (dir==2)?TILE_XY(TILE_X_MAX,r):0 +    // right

   304

          (dir==3)?TILE_XY(r,TILE_Y_MAX):0;     // bottom

   305

		j = 20;

   306

		do {

   307

			if (--j == 0)

   308

				goto restart;

   309

			tile = TILE_MASK(tile + _tile_add[dir]);

   310

		} while (!(IS_TILETYPE(tile, MP_CLEAR) && GetTileSlope(tile, &h) == 0 && h <= 16));

   311

   312

		assert(tile == TILE_MASK(tile));

   313

   314

		_map_type_and_height[tile] |= MP_UNMOVABLE << 4;

   315

		_map5[tile] = 1;

   316

		_map_owner[tile] = OWNER_NONE;

   317

	} while (--i);

   318

}

   319

   320

extern int32 CheckFlatLandBelow(uint tile, uint w, uint h, uint flags, uint invalid_dirs, int *);

   321

   322

/* p1				= relocate HQ

   323

	 p1&0xFF	= player whose HQ is up for relocation

   324

*/

   325

int32 CmdBuildCompanyHQ(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   326

{

   327

	uint tile = TILE_FROM_XY(x,y);

   328

	Player *p = DEREF_PLAYER(_current_player);

   329

	int score;

   330

	int32 cost = 0;

   331

   332

	if (CheckFlatLandBelow(tile, 2, 2, flags, 0, NULL) == CMD_ERROR)

   333

		return CMD_ERROR;

   334

   335

	if (p1)

   336

		cost = DoCommand(GET_TILE_X(p->location_of_house)*16, GET_TILE_Y(p->location_of_house)*16, p1&0xFF, 0, flags, CMD_DESTROY_COMPANY_HQ);

   337

   338

	if (flags & DC_EXEC) {

   339

		score = UpdateCompanyRatingAndValue(p, false);

   340

   341

		p->location_of_house = tile;

   342

   343

		ModifyTile(tile + TILE_XY(0,0),

   344

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   345

			0x80

   346

		);

   347

   348

		ModifyTile(tile + TILE_XY(0,1),

   349

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   350

			0x81

   351

		);

   352

   353

		ModifyTile(tile + TILE_XY(1,0),

   354

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   355

			0x82

   356

		);

   357

   358

		ModifyTile(tile + TILE_XY(1,1),

   359

			MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5,

   360

			0x83

   361

		);

   362

		UpdatePlayerHouse(p, score);

   363

		InvalidateWindow(WC_COMPANY, (int)p->index);

   364

	}

   365

   366

	return cost;

   367

}

   368

   369

/*	p1 = owner of the HQ */

   370

int32 CmdDestroyCompanyHQ(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   371

{

   372

	uint tile = TILE_FROM_XY(x,y);

   373

	Player *p;

   374

   375

	if ((int)p1 != OWNER_WATER)	// destruction was initiated by player

   376

		p = DEREF_PLAYER((byte)p1);

   377

	else {	// find player that has HQ flooded, and reset their location_of_house

   378

		bool dodelete = false;

   379

		FOR_ALL_PLAYERS(p) {

   380

			if (p->location_of_house == tile) {

   381

				dodelete = true;

   382

				break;

   383

			}

   384

		}

   385

		if (!dodelete)

   386

			return CMD_ERROR;

   387

	}

   388

   389

	if (flags & DC_EXEC) {

   390

		p->location_of_house = 0; // reset HQ position

   391

		DoClearSquare(tile + TILE_XY(0,0));

   392

		DoClearSquare(tile + TILE_XY(0,1));

   393

		DoClearSquare(tile + TILE_XY(1,0));

   394

		DoClearSquare(tile + TILE_XY(1,1));

   395

		InvalidateWindow(WC_COMPANY, (int)p->index);

   396

	}

   397

   398

	// cost of relocating company is 1% of company value

   399

	return CalculateCompanyValue(p) / 100;

   400

}

   401

   402

   403

static void ChangeTileOwner_Unmovable(uint tile, byte old_player, byte new_player)

   404

{

   405

	if (_map_owner[tile] != old_player)

   406

		return;

   407

   408

	if (_map5[tile]==3 && new_player != 255) {

   409

		_map_owner[tile] = new_player;

   410

	}	else {

   411

		DoClearSquare(tile);

   412

	}

   413

}

   414

   415

const TileTypeProcs _tile_type_unmovable_procs = {

   416

	DrawTile_Unmovable,						/* draw_tile_proc */

   417

	GetSlopeZ_Unmovable,					/* get_slope_z_proc */

   418

	ClearTile_Unmovable,					/* clear_tile_proc */

   419

	GetAcceptedCargo_Unmovable,		/* get_accepted_cargo_proc */

   420

	GetTileDesc_Unmovable,				/* get_tile_desc_proc */

   421

	GetTileTrackStatus_Unmovable,	/* get_tile_track_status_proc */

   422

	ClickTile_Unmovable,					/* click_tile_proc */

   423

	AnimateTile_Unmovable,				/* animate_tile_proc */

   424

	TileLoop_Unmovable,						/* tile_loop_clear */

   425

	ChangeTileOwner_Unmovable,		/* change_tile_owner_clear */

   426

	NULL,													/* get_produced_cargo_proc */

   427

	NULL,													/* vehicle_enter_tile_proc */

   428

	NULL,													/* vehicle_leave_tile_proc */

   429

	GetSlopeTileh_Unmovable,			/* get_slope_tileh_proc */

   430

};