1

/* $Id$ */

     2

     3

/** @file unmovable_cmd.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "table/sprites.h"

     9

#include "functions.h"

    10

#include "landscape.h"

    11

#include "map.h"

    12

#include "tile.h"

    13

#include "command.h"

    14

#include "viewport.h"

    15

#include "player.h"

    16

#include "gui.h"

    17

#include "station.h"

    18

#include "economy.h"

    19

#include "town.h"

    20

#include "sprite.h"

    21

#include "bridge_map.h"

    22

#include "unmovable_map.h"

    23

#include "variables.h"

    24

#include "table/unmovable_land.h"

    25

#include "genworld.h"

    26

#include "bridge.h"

    27

#include "autoslope.h"

    28

    29

/** Destroy a HQ.

    30

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

    31

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

    32

 * @param pid Player requesting the destruction of his HQ

    33

 * @param flags docommand flags of calling function

    34

 * @return cost of the operation

    35

 */

    36

static CommandCost DestroyCompanyHQ(PlayerID pid, uint32 flags)

    37

{

    38

	Player* p = GetPlayer(pid);

    39

    40

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

    41

    42

	if (flags & DC_EXEC) {

    43

		TileIndex t = p->location_of_house;

    44

    45

		DoClearSquare(t + TileDiffXY(0, 0));

    46

		DoClearSquare(t + TileDiffXY(0, 1));

    47

		DoClearSquare(t + TileDiffXY(1, 0));

    48

		DoClearSquare(t + TileDiffXY(1, 1));

    49

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

    50

		InvalidateWindow(WC_COMPANY, pid);

    51

	}

    52

    53

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

    54

	return CommandCost(CalculateCompanyValue(p) / 100);

    55

}

    56

    57

void UpdateCompanyHQ(Player *p, uint score)

    58

{

    59

	byte val;

    60

	TileIndex tile = p->location_of_house;

    61

    62

	if (tile == 0) return;

    63

    64

	(val = 0, score < 170) ||

    65

	(val++, score < 350) ||

    66

	(val++, score < 520) ||

    67

	(val++, score < 720) ||

    68

	(val++, true);

    69

    70

	EnlargeCompanyHQ(tile, val);

    71

    72

	MarkTileDirtyByTile(tile + TileDiffXY(0, 0));

    73

	MarkTileDirtyByTile(tile + TileDiffXY(0, 1));

    74

	MarkTileDirtyByTile(tile + TileDiffXY(1, 0));

    75

	MarkTileDirtyByTile(tile + TileDiffXY(1, 1));

    76

}

    77

    79

    80

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

    81

 * @param tile tile where the HQ will be built or relocated to

    82

 * @param flags type of operation

    83

 * @param p1 unused

    84

 * @param p2 unused

    85

 */

    86

CommandCost CmdBuildCompanyHQ(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

    87

{

    88

	Player *p = GetPlayer(_current_player);

    89

	CommandCost cost;

    90

    91

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

    92

    93

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

    94

	if (CmdFailed(cost)) return cost;

    95

    96

	if (p->location_of_house != 0) { // Moving HQ

    97

		cost.AddCost(DestroyCompanyHQ(_current_player, flags));

    98

	}

    99

   100

	if (flags & DC_EXEC) {

   101

		int score = UpdateCompanyRatingAndValue(p, false);

   102

   103

		p->location_of_house = tile;

   104

   105

		MakeCompanyHQ(tile, _current_player);

   106

   107

		UpdateCompanyHQ(p, score);

   108

		InvalidateWindow(WC_COMPANY, p->index);

   109

	}

   110

   111

	return cost;

   112

}

   113

   114

static Foundation GetFoundation_Unmovable(TileIndex tile, Slope tileh);

   115

   116

static void DrawTile_Unmovable(TileInfo *ti)

   117

{

   118

   119

	switch (GetUnmovableType(ti->tile)) {

   120

		case UNMOVABLE_TRANSMITTER:

   121

		case UNMOVABLE_LIGHTHOUSE: {

   122

			const DrawTileUnmovableStruct* dtus;

   123

   124

			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);

   125

			DrawClearLandTile(ti, 2);

   126

   127

			dtus = &_draw_tile_unmovable_data[GetUnmovableType(ti->tile)];

   128

   129

			AddSortableSpriteToDraw(

   130

				dtus->image, PAL_NONE, ti->x | dtus->subcoord_x, ti->y | dtus->subcoord_y,

   131

				dtus->width, dtus->height, dtus->z_size, ti->z,

   132

				HASBIT(_transparent_opt, TO_STRUCTURES)

   133

			);

   134

			break;

   135

		}

   136

   137

		case UNMOVABLE_STATUE:

   138

			/* This should prevent statues from sinking into the ground when on a slope. */

   139

			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, GetFoundation_Unmovable(ti->tile, ti->tileh));

   140

   141

			DrawGroundSprite(SPR_CONCRETE_GROUND, PAL_NONE);

   142

   143

			AddSortableSpriteToDraw(SPR_STATUE_COMPANY, PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile)), ti->x, ti->y, 16, 16, 25, ti->z, HASBIT(_transparent_opt, TO_STRUCTURES));

   144

			break;

   145

   146

		case UNMOVABLE_OWNED_LAND:

   147

			DrawClearLandTile(ti, 0);

   148

   149

			AddSortableSpriteToDraw(

   150

				SPR_BOUGHT_LAND, PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile)),

   151

				ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2, 1, 1, BB_HEIGHT_UNDER_BRIDGE, GetSlopeZ(ti->x + TILE_SIZE / 2, ti->y + TILE_SIZE / 2)

   152

			);

   153

			DrawBridgeMiddle(ti);

   154

			break;

   155

   156

		default: {

   157

			const DrawTileSeqStruct* dtss;

   158

			const DrawTileSprites* t;

   159

			SpriteID palette;

   160

   161

			assert(IsCompanyHQ(ti->tile));

   162

			if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);

   163

   164

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

   165

   166

			t = &_unmovable_display_datas[GetCompanyHQSection(ti->tile)];

   167

			DrawGroundSprite(t->ground_sprite, palette);

   168

   169

			foreach_draw_tile_seq(dtss, t->seq) {

   170

				AddSortableSpriteToDraw(

   171

					dtss->image, palette,

   172

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

   173

					dtss->size_x, dtss->size_y,

   174

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

   175

					HASBIT(_transparent_opt, TO_STRUCTURES)

   176

				);

   177

			}

   178

			break;

   179

		}

   180

	}

   181

}

   182

   183

static uint GetSlopeZ_Unmovable(TileIndex tile, uint x, uint y)

   184

{

   185

	if (IsOwnedLand(tile)) {

   186

		uint z;

   187

		Slope tileh = GetTileSlope(tile, &z);

   188

   189

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

   190

	} else {

   191

		return GetTileMaxZ(tile);

   192

	}

   193

}

   194

   195

static Foundation GetFoundation_Unmovable(TileIndex tile, Slope tileh)

   196

{

   197

	return IsOwnedLand(tile) ? FOUNDATION_NONE : FlatteningFoundation(tileh);

   198

}

   199

   200

static CommandCost ClearTile_Unmovable(TileIndex tile, byte flags)

   201

{

   202

	if (IsCompanyHQ(tile)) {

   203

		if (_current_player == OWNER_WATER) {

   204

			return DestroyCompanyHQ(GetTileOwner(tile), DC_EXEC);

   205

		} else {

   206

			return_cmd_error(STR_5804_COMPANY_HEADQUARTERS_IN);

   207

		}

   208

	}

   209

   210

	if (IsOwnedLand(tile)) {

   211

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

   212

	}

   213

   214

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

   215

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

   216

		return_cmd_error(STR_5800_OBJECT_IN_THE_WAY);

   217

   218

	if (IsStatue(tile)) {

   219

		TownID town = GetStatueTownID(tile);

   220

		CLRBIT(GetTown(town)->statues, _current_player);

   221

		InvalidateWindow(WC_TOWN_AUTHORITY, town);

   222

	}

   223

   224

	if (flags & DC_EXEC) {

   225

		DoClearSquare(tile);

   226

	}

   227

   228

	return CommandCost();

   229

}

   230

   231

static void GetAcceptedCargo_Unmovable(TileIndex tile, AcceptedCargo ac)

   232

{

   233

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

   234

   235

	if (!IsCompanyHQ(tile)) return;

   236

   237

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

   238

	 * between 4 tiles it occupies! */

   239

   240

	level = GetCompanyHQSize(tile) + 1;

   241

   242

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

   243

	 * type makes 20. */

   244

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

   245

   246

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

   247

	 * proportion passengers:mail is different because such a huge

   248

	 * commercial building generates unusually high amount of mail

   249

	 * correspondence per physical visitor. */

   250

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

   251

}

   252

   253

   254

static void GetTileDesc_Unmovable(TileIndex tile, TileDesc *td)

   255

{

   256

	switch (GetUnmovableType(tile)) {

   257

		case UNMOVABLE_TRANSMITTER: td->str = STR_5801_TRANSMITTER; break;

   258

		case UNMOVABLE_LIGHTHOUSE:  td->str = STR_5802_LIGHTHOUSE; break;

   259

		case UNMOVABLE_STATUE:      td->str = STR_2016_STATUE; break;

   260

		case UNMOVABLE_OWNED_LAND:  td->str = STR_5805_COMPANY_OWNED_LAND; break;

   261

		default:                    td->str = STR_5803_COMPANY_HEADQUARTERS; break;

   262

	}

   263

	td->owner = GetTileOwner(tile);

   264

}

   265

   266

static void AnimateTile_Unmovable(TileIndex tile)

   267

{

   268

	/* not used */

   269

}

   270

   271

static void TileLoop_Unmovable(TileIndex tile)

   272

{

   273

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

   274

	uint32 r;

   275

   276

	if (!IsCompanyHQ(tile)) return;

   277

   278

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

   279

	 * between 4 tiles it occupies! */

   280

   281

	level = GetCompanyHQSize(tile) + 1;

   282

	assert(level < 6);

   283

   284

	r = Random();

   285

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

   286

	if (GB(r, 0, 8) < (256 / 4 / (6 - level))) {

   287

		uint amt = GB(r, 0, 8) / 8 / 4 + 1;

   288

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

   289

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

   290

	}

   291

   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 (GB(r, 8, 8) < (196 / 4 / (6 - level))) {

   296

		uint amt = GB(r, 8, 8) / 8 / 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, uint sub_mode)

   304

{

   305

	return 0;

   306

}

   307

   308

static void ClickTile_Unmovable(TileIndex tile)

   309

{

   310

	if (IsCompanyHQ(tile)) ShowPlayerCompany(GetTileOwner(tile));

   311

}

   312

   313

   314

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

   315

static bool IsRadioTowerNearby(TileIndex tile)

   316

{

   317

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

   318

   319

	BEGIN_TILE_LOOP(tile, 9, 9, tile_s)

   320

		if (IsTransmitterTile(tile)) return true;

   321

	END_TILE_LOOP(tile, 9, 9, tile_s)

   322

   323

	return false;

   324

}

   325

   326

void GenerateUnmovables()

   327

{

   328

	int i, li, j, loop_count;

   329

	TileIndex tile;

   330

	uint h;

   331

	uint maxx;

   332

	uint maxy;

   333

   334

	if (_opt.landscape == LT_TOYLAND) return;

   335

   336

	/* add radio tower */

   337

	i = ScaleByMapSize(1000);

   338

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

   339

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

   340

	SetGeneratingWorldProgress(GWP_UNMOVABLE, j + li);

   341

   342

	do {

   343

		tile = RandomTile();

   344

		if (IsTileType(tile, MP_CLEAR) && GetTileSlope(tile, &h) == SLOPE_FLAT && h >= TILE_HEIGHT * 4 && !IsBridgeAbove(tile)) {

   345

			if (IsRadioTowerNearby(tile)) continue;

   346

			MakeTransmitter(tile);

   347

			IncreaseGeneratingWorldProgress(GWP_UNMOVABLE);

   348

			if (--j == 0) break;

   349

		}

   350

	} while (--i);

   351

   352

	if (_opt.landscape == LT_TROPIC) return;

   353

   354

	/* add lighthouses */

   355

	i = li;

   356

	maxx = MapMaxX();

   357

	maxy = MapMaxY();

   358

	loop_count = 0;

   359

	do {

   360

		uint32 r;

   361

		DiagDirection dir;

   362

		int perimeter;

   363

   364

restart:

   365

		/* Avoid infinite loops */

   366

		if (++loop_count > 1000) break;

   367

   368

		r = Random();

   369

   370

		/* Scatter the lighthouses more evenly around the perimeter */

   371

		perimeter = (GB(r, 16, 16) % (2 * (maxx + maxy))) - maxy;

   372

		for (dir = DIAGDIR_NE; perimeter > 0; dir++) {

   373

			perimeter -= (DiagDirToAxis(dir) == AXIS_X) ? maxx : maxy;

   374

		}

   375

   376

		switch (dir) {

   377

			default:

   378

			case DIAGDIR_NE: tile = TileXY(maxx,     r % maxy); break;

   379

			case DIAGDIR_SE: tile = TileXY(r % maxx, 0);        break;

   380

			case DIAGDIR_SW: tile = TileXY(0,        r % maxy); break;

   381

			case DIAGDIR_NW: tile = TileXY(r % maxx, maxy);     break;

   382

		}

   383

		j = 20;

   384

		do {

   385

			if (--j == 0) goto restart;

   386

			tile = TILE_MASK(tile + TileOffsByDiagDir(dir));

   387

		} while (!(IsTileType(tile, MP_CLEAR) && GetTileSlope(tile, &h) == SLOPE_FLAT && h <= TILE_HEIGHT * 2 && !IsBridgeAbove(tile)));

   388

   389

		assert(tile == TILE_MASK(tile));

   390

   391

		MakeLighthouse(tile);

   392

		IncreaseGeneratingWorldProgress(GWP_UNMOVABLE);

   393

	} while (--i);

   394

}

   395

   396

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

   397

{

   398

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

   399

   400

	if (IsOwnedLand(tile) && new_player != PLAYER_SPECTATOR) {

   401

		SetTileOwner(tile, new_player);

   402

	} else {

   403

		DoClearSquare(tile);

   404

	}

   405

}

   406

   407

static CommandCost TerraformTile_Unmovable(TileIndex tile, uint32 flags, uint z_new, Slope tileh_new)

   408

{

   409

	/* Owned land remains unsold */

   410

	if (IsOwnedLand(tile) && CheckTileOwnership(tile)) return CommandCost();

   411

   412

	if (AutoslopeEnabled() && (IsStatue(tile) || IsCompanyHQ(tile))) {

   413

		if (!IsSteepSlope(tileh_new) && (z_new + GetSlopeMaxZ(tileh_new) == GetTileMaxZ(tile))) return _price.terraform;

   414

	}

   415

   416

	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   417

}

   418

   419

extern const TileTypeProcs _tile_type_unmovable_procs = {

   420

	DrawTile_Unmovable,             /* draw_tile_proc */

   421

	GetSlopeZ_Unmovable,            /* get_slope_z_proc */

   422

	ClearTile_Unmovable,            /* clear_tile_proc */

   423

	GetAcceptedCargo_Unmovable,     /* get_accepted_cargo_proc */

   424

	GetTileDesc_Unmovable,          /* get_tile_desc_proc */

   425

	GetTileTrackStatus_Unmovable,   /* get_tile_track_status_proc */

   426

	ClickTile_Unmovable,            /* click_tile_proc */

   427

	AnimateTile_Unmovable,          /* animate_tile_proc */

   428

	TileLoop_Unmovable,             /* tile_loop_clear */

   429

	ChangeTileOwner_Unmovable,      /* change_tile_owner_clear */

   430

	NULL,                           /* get_produced_cargo_proc */

   431

	NULL,                           /* vehicle_enter_tile_proc */

   432

	GetFoundation_Unmovable,        /* get_foundation_proc */

   433

	TerraformTile_Unmovable,        /* terraform_tile_proc */

   434

};