1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "command.h"

     7

#include "viewport.h"

     8

#include "player.h"

     9

#include "gui.h"

    10

#include "station.h"

    11

#include "economy.h"

    12

#include "town.h"

    13

#include "sprite.h"

    14

    15

/** Destroy a HQ.

    16

 * During normal gameplay you can only implicitely destroy a HQ when you are

    17

 * rebuilding it. Otherwise, only water can destroy it.

    18

 * @param tile tile coordinates where HQ is located to destroy

    19

 * @param flags docommand flags of calling function

    20

 */

    21

int32 DestroyCompanyHQ(TileIndex tile, uint32 flags)

    22

{

    23

	Player *p;

    24

    25

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

    26

    27

	/* Find player that has HQ flooded, and reset their location_of_house */

    28

	if (_current_player == OWNER_WATER) {

    29

		bool dodelete = false;

    30

    31

		FOR_ALL_PLAYERS(p) {

    32

			if (p->location_of_house == tile) {

    33

				dodelete = true;

    34

				break;

    35

			}

    36

		}

    37

		if (!dodelete) return CMD_ERROR;

    38

	} else /* Destruction was initiated by player */

    39

		p = GetPlayer(_current_player);

    40

    41

		if (p->location_of_house == 0) return CMD_ERROR;

    42

    43

		if (flags & DC_EXEC) {

    44

			DoClearSquare(p->location_of_house + TileDiffXY(0, 0));

    45

			DoClearSquare(p->location_of_house + TileDiffXY(0, 1));

    46

			DoClearSquare(p->location_of_house + TileDiffXY(1, 0));

    47

			DoClearSquare(p->location_of_house + TileDiffXY(1, 1));

    48

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

    49

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

    50

		}

    51

    52

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

    53

		return CalculateCompanyValue(p) / 100;

    54

}

    55

    56

/** Build or relocate the HQ. This depends if the HQ is already built or not

    57

 * @param x,y the coordinates where the HQ will be built or relocated to

    58

 * @param p1 relocate HQ (set to some value, usually 1 or true)

    59

 * @param p2 unused

    60

 */

    61

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

    62

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

    63

{

    64

	TileIndex tile = TileVirtXY(x, y);

    65

	Player *p = GetPlayer(_current_player);

    66

	int cost;

    67

    68

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

    69

    70

	cost = CheckFlatLandBelow(tile, 2, 2, flags, 0, NULL);

    71

	if (CmdFailed(cost)) return CMD_ERROR;

    72

    73

	if (p1) { /* Moving HQ */

    74

		int32 ret;

    75

    76

		if (p->location_of_house == 0) return CMD_ERROR;

    77

    78

		ret = DestroyCompanyHQ(p->location_of_house, flags);

    79

    80

		if (CmdFailed(ret)) return CMD_ERROR;

    81

    82

		cost += ret;

    83

	} else { /* Building new HQ */

    84

		if (p->location_of_house != 0) return CMD_ERROR;

    85

	}

    86

    87

	if (flags & DC_EXEC) {

    88

		int score = UpdateCompanyRatingAndValue(p, false);

    89

    90

		p->location_of_house = tile;

    91

    92

		ModifyTile(tile + TileDiffXY(0, 0), MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5, 0x80);

    93

		ModifyTile(tile + TileDiffXY(0, 1), MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5, 0x81);

    94

		ModifyTile(tile + TileDiffXY(1, 0), MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5, 0x82);

    95

		ModifyTile(tile + TileDiffXY(1, 1), MP_SETTYPE(MP_UNMOVABLE) | MP_MAPOWNER_CURRENT | MP_MAP5, 0x83);

    96

		UpdatePlayerHouse(p, score);

    97

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

    98

	}

    99

   100

	return cost;

   101

}

   102

   103

typedef struct DrawTileUnmovableStruct {

   104

	uint16 image;

   105

	byte subcoord_x;

   106

	byte subcoord_y;

   107

	byte width;

   108

	byte height;

   109

	byte z_size;

   110

	byte unused;

   111

} DrawTileUnmovableStruct;

   112

   113

#include "table/unmovable_land.h"

   114

   115

static void DrawTile_Unmovable(TileInfo *ti)

   116

{

   117

	uint32 image, ormod;

   118

   119

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

   120

		if (ti->map5 == 2) {

   121

   122

			// statue

   123

			DrawGroundSprite(0x58C);

   124

   125

			image = PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile));

   126

			image += 0x8A48;

   127

			if (_display_opt & DO_TRANS_BUILDINGS)

   128

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

   129

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

   130

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

   131

   132

			// "owned by" sign

   133

			DrawClearLandTile(ti, 0);

   134

   135

			AddSortableSpriteToDraw(

   136

				PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile)) + 0x92B6,

   137

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

   138

				1, 1,

   139

				10,

   140

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

   141

			);

   142

		} else {

   143

			// lighthouse or transmitter

   144

   145

			const DrawTileUnmovableStruct *dtus;

   146

   147

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

   148

			DrawClearLandTile(ti, 2);

   149

   150

			dtus = &_draw_tile_unmovable_data[ti->map5];

   151

   152

			image = dtus->image;

   153

			if (_display_opt & DO_TRANS_BUILDINGS)

   154

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

   155

   156

			AddSortableSpriteToDraw(image,

   157

				ti->x | dtus->subcoord_x,

   158

				ti->y | dtus->subcoord_y,

   159

				dtus->width, dtus->height,

   160

				dtus->z_size, ti->z);

   161

		}

   162

	} else {

   163

		const DrawTileSeqStruct *dtss;

   164

		const DrawTileSprites *t;

   165

   166

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

   167

   168

		ormod = PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile));

   169

   170

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

   171

		DrawGroundSprite(t->ground_sprite | ormod);

   172

   173

		foreach_draw_tile_seq(dtss, t->seq) {

   174

			image = dtss->image;

   175

			if (_display_opt & DO_TRANS_BUILDINGS) {

   176

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

   177

			} else {

   178

				image |= ormod;

   179

			}

   180

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

   181

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

   182

		}

   183

	}

   184

}

   185

   186

static uint GetSlopeZ_Unmovable(TileInfo *ti)

   187

{

   188

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

   189

}

   190

   191

static uint GetSlopeTileh_Unmovable(TileInfo *ti)

   192

{

   193

	return 0;

   194

}

   195

   196

static int32 ClearTile_Unmovable(TileIndex tile, byte flags)

   197

{

   199

   200

	if (m5 & 0x80) {

   201

		if (_current_player == OWNER_WATER) return DestroyCompanyHQ(tile, DC_EXEC);

   202

		return_cmd_error(STR_5804_COMPANY_HEADQUARTERS_IN);

   203

	}

   204

   205

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

   206

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

   207

   208

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

   209

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

   210

		return_cmd_error(STR_5800_OBJECT_IN_THE_WAY);

   211

   212

	if (flags & DC_EXEC) {

   213

		DoClearSquare(tile);

   214

	}

   215

   216

	return 0;

   217

}

   218

   219

static void GetAcceptedCargo_Unmovable(TileIndex tile, AcceptedCargo ac)

   220

{

   222

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

   223

   224

	if (!(m5 & 0x80)) {

   225

		/* not used */

   226

		return;

   227

	}

   228

   229

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

   230

	 * between 4 tiles it occupies! */

   231

   232

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

   233

   234

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

   235

	// type makes 20.

   236

	ac[CT_PASSENGERS] = max(1, level);

   237

   238

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

   239

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

   240

	// commercial building generates unusually high amount of mail

   241

	// correspondence per physical visitor.

   242

	ac[CT_MAIL] = max(1, level / 2);

   243

}

   244

   245

static const StringID _unmovable_tile_str[] = {

   246

	STR_5803_COMPANY_HEADQUARTERS,

   247

	STR_5801_TRANSMITTER,

   248

	STR_5802_LIGHTHOUSE,

   249

	STR_2016_STATUE,

   250

	STR_5805_COMPANY_OWNED_LAND,

   251

};

   252

   253

static void GetTileDesc_Unmovable(TileIndex tile, TileDesc *td)

   254

{

   256

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

   257

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

   258

	td->owner = GetTileOwner(tile);

   259

}

   260

   261

static void AnimateTile_Unmovable(TileIndex tile)

   262

{

   263

	/* not used */

   264

}

   265

   266

static void TileLoop_Unmovable(TileIndex tile)

   267

{

   269

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

   270

	uint32 r;

   271

   272

	if (!(m5 & 0x80)) {

   273

		/* not used */

   274

		return;

   275

	}

   276

   277

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

   278

	 * between 4 tiles it occupies! */

   279

   280

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

   281

	assert(level < 6);

   282

   283

	r = Random();

   284

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

   285

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

   286

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

   287

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

   288

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

   289

	}

   290

   291

	r >>= 8;

   292

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

   293

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

   294

	// equations.

   295

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

   296

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

   297

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

   298

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

   299

	}

   300

}

   301

   302

   303

static uint32 GetTileTrackStatus_Unmovable(TileIndex tile, TransportType mode)

   304

{

   305

	return 0;

   306

}

   307

   308

static void ClickTile_Unmovable(TileIndex tile)

   309

{

   311

		ShowPlayerCompany(GetTileOwner(tile));

   312

	}

   313

}

   314

   315

static const TileIndexDiffC _tile_add[] = {

   316

	{ 1,  0},

   317

	{ 0,  1},

   318

	{-1,  0},

   319

	{ 0, -1}

   320

};

   321

   322

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

   323

static bool checkRadioTowerNearby(TileIndex tile)

   324

{

   325

	TileIndex tile_s = tile - TileDiffXY(4, 4);

   326

   327

	BEGIN_TILE_LOOP(tile, 9, 9, tile_s)

   328

		// already a radio tower here?

   330

			return false;

   331

	END_TILE_LOOP(tile, 9, 9, tile_s)

   332

	return true;

   333

}

   334

   335

void GenerateUnmovables(void)

   336

{

   337

	int i,j;

   338

	TileIndex tile;

   339

	uint32 r;

   340

	int dir;

   341

	uint h;

   342

   343

	if (_opt.landscape == LT_CANDY)

   344

		return;

   345

   346

	/* add radio tower */

   347

	i = ScaleByMapSize(1000);

   348

	j = ScaleByMapSize(40); // maximum number of radio towers on the map

   349

	do {

   350

		r = Random();

   351

		tile = r % MapSize();

   352

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

   353

//		tile = TILE_MASK(r);

   354

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

   355

			if(!checkRadioTowerNearby(tile))

   356

				continue;

   357

			SetTileType(tile, MP_UNMOVABLE);

   359

			SetTileOwner(tile, OWNER_NONE);

   360

			if (--j == 0)

   361

				break;

   362

		}

   363

	} while (--i);

   364

   365

	if (_opt.landscape == LT_DESERT)

   366

		return;

   367

   368

	/* add lighthouses */

   369

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

   370

	do {

   371

restart:

   372

		r = Random();

   373

		dir = r >> 30;

   374

		r %= (dir == 0 || dir == 2) ? MapMaxY() : MapMaxX();

   375

		tile =

   376

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

   377

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

   378

			(dir == 2) ? TileXY(MapMaxX(), r) : 0 + // right

   379

			(dir == 3) ? TileXY(r, MapMaxY()) : 0;  // bottom

   380

		j = 20;

   381

		do {

   382

			if (--j == 0)

   383

				goto restart;

   384

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

   385

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

   386

   387

		assert(tile == TILE_MASK(tile));

   388

   389

		SetTileType(tile, MP_UNMOVABLE);

   391

		SetTileOwner(tile, OWNER_NONE);

   392

	} while (--i);

   393

}

   394

   395

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

   396

{

   397

	if (!IsTileOwner(tile, old_player)) return;

   398

   400

		SetTileOwner(tile, new_player);

   401

	} else {

   402

		DoClearSquare(tile);

   403

	}

   404

}

   405

   406

const TileTypeProcs _tile_type_unmovable_procs = {

   407

	DrawTile_Unmovable,             /* draw_tile_proc */

   408

	GetSlopeZ_Unmovable,            /* get_slope_z_proc */

   409

	ClearTile_Unmovable,            /* clear_tile_proc */

   410

	GetAcceptedCargo_Unmovable,     /* get_accepted_cargo_proc */

   411

	GetTileDesc_Unmovable,          /* get_tile_desc_proc */

   412

	GetTileTrackStatus_Unmovable,   /* get_tile_track_status_proc */

   413

	ClickTile_Unmovable,            /* click_tile_proc */

   414

	AnimateTile_Unmovable,          /* animate_tile_proc */

   415

	TileLoop_Unmovable,             /* tile_loop_clear */

   416

	ChangeTileOwner_Unmovable,      /* change_tile_owner_clear */

   417

	NULL,                           /* get_produced_cargo_proc */

   418

	NULL,                           /* vehicle_enter_tile_proc */

   419

	NULL,                           /* vehicle_leave_tile_proc */

   420

	GetSlopeTileh_Unmovable,        /* get_slope_tileh_proc */

   421

};