1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "table/strings.h"

     6

#include "table/sprites.h"

     7

#include "functions.h"

     8

#include "map.h"

     9

#include "tile.h"

    10

#include "command.h"

    11

#include "viewport.h"

    12

#include "player.h"

    13

#include "gui.h"

    14

#include "station.h"

    15

#include "economy.h"

    16

#include "town.h"

    17

#include "sprite.h"

    18

#include "unmovable_map.h"

    19

#include "variables.h"

    20

    21

/** Destroy a HQ.

    22

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

    23

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

    24

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

    25

 * @param flags docommand flags of calling function

    26

 */

    27

static int32 DestroyCompanyHQ(TileIndex tile, uint32 flags)

    28

{

    29

	Player *p;

    30

    31

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

    32

    33

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

    34

	if (_current_player == OWNER_WATER) {

    35

		bool dodelete = false;

    36

    37

		FOR_ALL_PLAYERS(p) {

    38

			if (p->location_of_house == tile) {

    39

				dodelete = true;

    40

				break;

    41

			}

    42

		}

    43

		if (!dodelete) return CMD_ERROR;

    44

	} else /* Destruction was initiated by player */

    45

		p = GetPlayer(_current_player);

    46

    47

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

    48

    49

		if (flags & DC_EXEC) {

    50

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

    51

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

    52

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

    53

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

    54

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

    55

			InvalidateWindow(WC_COMPANY, p->index);

    56

		}

    57

    58

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

    59

		return CalculateCompanyValue(p) / 100;

    60

}

    61

    62

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

    63

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

    64

 * @param p1 unused

    65

 * @param p2 unused

    66

 */

    67

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

    68

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

    69

{

    70

	TileIndex tile = TileVirtXY(x, y);

    71

	Player *p = GetPlayer(_current_player);

    72

	int cost;

    73

	int32 ret;

    74

    75

	SET_EXPENSES_TYPE(EXPENSES_PROPERTY);

    76

    77

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

    78

	if (CmdFailed(ret)) return ret;

    79

	cost = ret;

    80

    81

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

    82

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

    83

		if (CmdFailed(ret)) return CMD_ERROR;

    84

		cost += ret;

    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, 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(SPR_CONCRETE_GROUND);

   124

   125

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

   126

			image += PALETTE_MODIFIER_COLOR | SPR_STATUE_COMPANY;

   127

			if (_display_opt & DO_TRANS_BUILDINGS)

   128

				MAKE_TRANSPARENT(image);

   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)) + PALETTE_MODIFIER_COLOR + SPR_BOUGHT_LAND,

   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

				MAKE_TRANSPARENT(image);

   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

				MAKE_TRANSPARENT(image);

   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(const TileInfo* ti)

   187

{

   188

	if (IsOwnedLand(ti->tile)) {

   189

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

   190

	} else {

   191

		return ti->z + (ti->tileh == 0 ? 0 : 8);

   192

	}

   193

}

   194

   195

static uint GetSlopeTileh_Unmovable(const TileInfo *ti)

   196

{

   197

	return IsOwnedLand(ti->tile) ? ti->tileh : 0;

   198

}

   199

   200

static int32 ClearTile_Unmovable(TileIndex tile, byte flags)

   201

{

   202

	if (_m[tile].m5 & 0x80) {

   203

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

   204

		return_cmd_error(STR_5804_COMPANY_HEADQUARTERS_IN);

   205

	}

   206

   207

	if (IsOwnedLand(tile)) {

   208

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

   209

	}

   210

   211

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

   212

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

   213

		return_cmd_error(STR_5800_OBJECT_IN_THE_WAY);

   214

   215

	if (flags & DC_EXEC) {

   216

		DoClearSquare(tile);

   217

	}

   218

   219

	return 0;

   220

}

   221

   222

static void GetAcceptedCargo_Unmovable(TileIndex tile, AcceptedCargo ac)

   223

{

   224

	byte m5 = _m[tile].m5;

   225

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

   226

   227

	if (!(m5 & 0x80)) {

   228

		/* not used */

   229

		return;

   230

	}

   231

   232

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

   233

	 * between 4 tiles it occupies! */

   234

   235

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

   236

   237

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

   238

	// type makes 20.

   239

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

   240

   241

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

   242

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

   243

	// commercial building generates unusually high amount of mail

   244

	// correspondence per physical visitor.

   245

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

   246

}

   247

   248

   249

static void GetTileDesc_Unmovable(TileIndex tile, TileDesc *td)

   250

{

   251

	switch (GetUnmovableType(tile)) {

   252

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

   253

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

   254

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

   255

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

   256

		default:                    td->str = STR_5803_COMPANY_HEADQUARTERS; break;

   257

	}

   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

{

   268

	byte m5 = _m[tile].m5;

   269

	uint 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 = GB(m5, 0, 7) / 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 (GB(r, 0, 8) < (256 / 4 / (6 - level))) {

   286

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

   287

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

   288

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

   289

	}

   290

   291

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

   292

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

   293

	// equations.

   294

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

   295

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

   296

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

   297

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

   298

	}

   299

}

   300

   301

   302

static uint32 GetTileTrackStatus_Unmovable(TileIndex tile, TransportType mode)

   303

{

   304

	return 0;

   305

}

   306

   307

static void ClickTile_Unmovable(TileIndex tile)

   308

{

   309

	if (_m[tile].m5 & 0x80) {

   310

		ShowPlayerCompany(GetTileOwner(tile));

   311

	}

   312

}

   313

   314

   315

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

   316

static bool checkRadioTowerNearby(TileIndex tile)

   317

{

   318

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

   319

   320

	BEGIN_TILE_LOOP(tile, 9, 9, tile_s)

   321

		if (IsTransmitterTile(tile)) return false;

   322

	END_TILE_LOOP(tile, 9, 9, tile_s)

   323

	return true;

   324

}

   325

   326

void GenerateUnmovables(void)

   327

{

   328

	int i,j;

   329

	TileIndex tile;

   330

	uint h;

   331

	uint maxx;

   332

	uint maxy;

   333

   334

	if (_opt.landscape == LT_CANDY) return;

   335

   336

	/* add radio tower */

   337

	i = ScaleByMapSize(1000);

   338

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

   339

	do {

   340

		tile = RandomTile();

   341

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

   342

			if (!checkRadioTowerNearby(tile)) continue;

   343

			MakeTransmitter(tile);

   344

			if (--j == 0) break;

   345

		}

   346

	} while (--i);

   347

   348

	if (_opt.landscape == LT_DESERT) return;

   349

   350

	/* add lighthouses */

   351

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

   352

	maxx = MapMaxX();

   353

	maxy = MapMaxY();

   354

	do {

   355

		uint32 r;

   356

		DiagDirection dir;

   357

   358

restart:

   359

		r = Random();

   360

		dir = GB(r, 30, 2);

   361

		switch (dir) {

   362

			default:

   363

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

   364

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

   365

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

   366

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

   367

		}

   368

		j = 20;

   369

		do {

   370

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

   371

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

   372

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

   373

   374

		assert(tile == TILE_MASK(tile));

   375

   376

		MakeLighthouse(tile);

   377

	} while (--i);

   378

}

   379

   380

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

   381

{

   382

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

   383

   384

	if (_m[tile].m5 == 3 && new_player != OWNER_SPECTATOR) {

   385

		SetTileOwner(tile, new_player);

   386

	} else {

   387

		DoClearSquare(tile);

   388

	}

   389

}

   390

   391

const TileTypeProcs _tile_type_unmovable_procs = {

   392

	DrawTile_Unmovable,             /* draw_tile_proc */

   393

	GetSlopeZ_Unmovable,            /* get_slope_z_proc */

   394

	ClearTile_Unmovable,            /* clear_tile_proc */

   395

	GetAcceptedCargo_Unmovable,     /* get_accepted_cargo_proc */

   396

	GetTileDesc_Unmovable,          /* get_tile_desc_proc */

   397

	GetTileTrackStatus_Unmovable,   /* get_tile_track_status_proc */

   398

	ClickTile_Unmovable,            /* click_tile_proc */

   399

	AnimateTile_Unmovable,          /* animate_tile_proc */

   400

	TileLoop_Unmovable,             /* tile_loop_clear */

   401

	ChangeTileOwner_Unmovable,      /* change_tile_owner_clear */

   402

	NULL,                           /* get_produced_cargo_proc */

   403

	NULL,                           /* vehicle_enter_tile_proc */

   404

	NULL,                           /* vehicle_leave_tile_proc */

   405

	GetSlopeTileh_Unmovable,        /* get_slope_tileh_proc */

   406

};