1

/* $Id$ */

     2

     3

/** @file company_cmd.cpp Handling of companies. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "engine_func.h"

     8

#include "engine_base.h"

     9

#include "company_func.h"

    10

#include "company_gui.h"

    11

#include "town.h"

    12

#include "news_func.h"

    13

#include "saveload.h"

    14

#include "command_func.h"

    15

#include "network/network.h"

    16

#include "network/network_func.h"

    17

#include "variables.h"

    18

#include "cheat_func.h"

    19

#include "ai/ai.h"

    20

#include "company_manager_face.h"

    21

#include "group.h"

    22

#include "window_func.h"

    23

#include "tile_map.h"

    24

#include "strings_func.h"

    25

#include "gfx_func.h"

    26

#include "functions.h"

    27

#include "date_func.h"

    28

#include "vehicle_func.h"

    29

#include "sound_func.h"

    30

#include "core/alloc_func.hpp"

    31

#include "core/sort_func.hpp"

    32

#include "autoreplace_func.h"

    33

#include "autoreplace_gui.h"

    34

#include "string_func.h"

    35

#include "ai/default/default.h"

    36

#include "ai/trolly/trolly.h"

    37

#include "road_func.h"

    38

#include "rail.h"

    39

#include "sprite.h"

    40

#include "debug.h"

    41

#include "oldpool_func.h"

    42

    43

#include "table/strings.h"

    44

#include "table/sprites.h"

    45

    46

CompanyByte _local_company;

    47

CompanyByte _current_company;

    48

/* NOSAVE: can be determined from company structs */

    49

byte _company_colours[MAX_COMPANIES];

    50

CompanyManagerFace _company_manager_face; ///< for company manager face storage in openttd.cfg

    51

HighScore _highscore_table[5][5]; // 4 difficulty-settings (+ network); top 5

    52

    53

DEFINE_OLD_POOL_GENERIC(Company, Company)

    54

    55

Company::Company(uint16 name_1, bool is_ai) : name_1(name_1), is_ai(is_ai)

    56

{

    57

	for (uint j = 0; j < 4; j++) this->share_owners[j] = COMPANY_SPECTATOR;

    58

}

    59

    60

Company::~Company()

    61

{

    62

	free(this->name);

    63

	free(this->president_name);

    64

	free(this->num_engines);

    65

    66

	if (CleaningPool()) return;

    67

    68

	DeleteCompanyWindows(this->index);

    69

	this->name_1 = 0;

    70

}

    71

    72

/**

    73

 * Sets the local company and updates the patch settings that are set on a

    74

 * per-company basis to reflect the core's state in the GUI.

    75

 * @param new_company the new company

    76

 * @pre IsValidCompanyID(new_company) || new_company == COMPANY_SPECTATOR || new_company == OWNER_NONE

    77

 */

    78

void SetLocalCompany(CompanyID new_company)

    79

{

    80

	/* company could also be COMPANY_SPECTATOR or OWNER_NONE */

    81

	assert(IsValidCompanyID(new_company) || new_company == COMPANY_SPECTATOR || new_company == OWNER_NONE);

    82

    83

	_local_company = new_company;

    84

    85

	/* Do not update the patches if we are in the intro GUI */

    86

	if (IsValidCompanyID(new_company) && _game_mode != GM_MENU) {

    87

		const Company *c = GetCompany(new_company);

    88

		_settings_client.gui.autorenew        = c->engine_renew;

    89

		_settings_client.gui.autorenew_months = c->engine_renew_months;

    90

		_settings_client.gui.autorenew_money  = c->engine_renew_money;

    91

		InvalidateWindow(WC_GAME_OPTIONS, 0);

    92

	}

    93

}

    94

    95

bool IsHumanCompany(CompanyID company)

    96

{

    97

	return !GetCompany(company)->is_ai;

    98

}

    99

   100

   101

uint16 GetDrawStringCompanyColor(CompanyID company)

   102

{

   103

	/* Get the color for DrawString-subroutines which matches the color

   104

	 * of the company */

   105

	if (!IsValidCompanyID(company)) return _colour_gradient[COLOUR_WHITE][4] | IS_PALETTE_COLOR;

   106

	return (_colour_gradient[_company_colours[company]][4]) | IS_PALETTE_COLOR;

   107

}

   108

   109

void DrawCompanyIcon(CompanyID c, int x, int y)

   110

{

   111

	DrawSprite(SPR_PLAYER_ICON, COMPANY_SPRITE_COLOR(c), x, y);

   112

}

   113

   114

/**

   115

 * Converts an old company manager's face format to the new company manager's face format

   116

 *

   117

 * Meaning of the bits in the old face (some bits are used in several times):

   118

 * - 4 and 5: chin

   119

 * - 6 to 9: eyebrows

   120

 * - 10 to 13: nose

   121

 * - 13 to 15: lips (also moustache for males)

   122

 * - 16 to 19: hair

   123

 * - 20 to 22: eye color

   124

 * - 20 to 27: tie, ear rings etc.

   125

 * - 28 to 30: glasses

   126

 * - 19, 26 and 27: race (bit 27 set and bit 19 equal to bit 26 = black, otherwise white)

   127

 * - 31: gender (0 = male, 1 = female)

   128

 *

   129

 * @param face the face in the old format

   130

 * @return the face in the new format

   131

 */

   132

CompanyManagerFace ConvertFromOldCompanyManagerFace(uint32 face)

   133

{

   134

	CompanyManagerFace cmf = 0;

   135

	GenderEthnicity ge = GE_WM;

   136

   137

	if (HasBit(face, 31)) SetBit(ge, GENDER_FEMALE);

   138

	if (HasBit(face, 27) && (HasBit(face, 26) == HasBit(face, 19))) SetBit(ge, ETHNICITY_BLACK);

   139

   140

	SetCompanyManagerFaceBits(cmf, CMFV_GEN_ETHN,    ge, ge);

   141

	SetCompanyManagerFaceBits(cmf, CMFV_HAS_GLASSES, ge, GB(face, 28, 3) <= 1);

   142

	SetCompanyManagerFaceBits(cmf, CMFV_EYE_COLOUR,  ge, HasBit(ge, ETHNICITY_BLACK) ? 0 : ClampU(GB(face, 20, 3), 5, 7) - 5);

   143

	SetCompanyManagerFaceBits(cmf, CMFV_CHIN,        ge, ScaleCompanyManagerFaceValue(CMFV_CHIN,     ge, GB(face,  4, 2)));

   144

	SetCompanyManagerFaceBits(cmf, CMFV_EYEBROWS,    ge, ScaleCompanyManagerFaceValue(CMFV_EYEBROWS, ge, GB(face,  6, 4)));

   145

	SetCompanyManagerFaceBits(cmf, CMFV_HAIR,        ge, ScaleCompanyManagerFaceValue(CMFV_HAIR,     ge, GB(face, 16, 4)));

   146

	SetCompanyManagerFaceBits(cmf, CMFV_JACKET,      ge, ScaleCompanyManagerFaceValue(CMFV_JACKET,   ge, GB(face, 20, 2)));

   147

	SetCompanyManagerFaceBits(cmf, CMFV_COLLAR,      ge, ScaleCompanyManagerFaceValue(CMFV_COLLAR,   ge, GB(face, 22, 2)));

   148

	SetCompanyManagerFaceBits(cmf, CMFV_GLASSES,     ge, GB(face, 28, 1));

   149

   150

	uint lips = GB(face, 10, 4);

   151

	if (!HasBit(ge, GENDER_FEMALE) && lips < 4) {

   152

		SetCompanyManagerFaceBits(cmf, CMFV_HAS_MOUSTACHE, ge, true);

   153

		SetCompanyManagerFaceBits(cmf, CMFV_MOUSTACHE,     ge, max(lips, 1U) - 1);

   154

	} else {

   155

		if (!HasBit(ge, GENDER_FEMALE)) {

   156

			lips = lips * 15 / 16;

   157

			lips -= 3;

   158

			if (HasBit(ge, ETHNICITY_BLACK) && lips > 8) lips = 0;

   159

		} else {

   160

			lips = ScaleCompanyManagerFaceValue(CMFV_LIPS, ge, lips);

   161

		}

   162

		SetCompanyManagerFaceBits(cmf, CMFV_LIPS, ge, lips);

   163

   164

		uint nose = GB(face, 13, 3);

   165

		if (ge == GE_WF) {

   166

			nose = (nose * 3 >> 3) * 3 >> 2; // There is 'hole' in the nose sprites for females

   167

		} else {

   168

			nose = ScaleCompanyManagerFaceValue(CMFV_NOSE, ge, nose);

   169

		}

   170

		SetCompanyManagerFaceBits(cmf, CMFV_NOSE, ge, nose);

   171

	}

   172

   173

	uint tie_earring = GB(face, 24, 4);

   174

	if (!HasBit(ge, GENDER_FEMALE) || tie_earring < 3) { // Not all females have an earring

   175

		if (HasBit(ge, GENDER_FEMALE)) SetCompanyManagerFaceBits(cmf, CMFV_HAS_TIE_EARRING, ge, true);

   176

		SetCompanyManagerFaceBits(cmf, CMFV_TIE_EARRING, ge, HasBit(ge, GENDER_FEMALE) ? tie_earring : ScaleCompanyManagerFaceValue(CMFV_TIE_EARRING, ge, tie_earring / 2));

   177

	}

   178

   179

	return cmf;

   180

}

   181

   182

/**

   183

 * Checks whether a company manager's face is a valid encoding.

   184

 * Unused bits are not enforced to be 0.

   185

 * @param cmf the fact to check

   186

 * @return true if and only if the face is valid

   187

 */

   188

bool IsValidCompanyManagerFace(CompanyManagerFace cmf)

   189

{

   190

	if (!AreCompanyManagerFaceBitsValid(cmf, CMFV_GEN_ETHN, GE_WM)) return false;

   191

   192

	GenderEthnicity ge   = (GenderEthnicity)GetCompanyManagerFaceBits(cmf, CMFV_GEN_ETHN, GE_WM);

   193

	bool has_moustache   = !HasBit(ge, GENDER_FEMALE) && GetCompanyManagerFaceBits(cmf, CMFV_HAS_MOUSTACHE,   ge) != 0;

   194

	bool has_tie_earring = !HasBit(ge, GENDER_FEMALE) || GetCompanyManagerFaceBits(cmf, CMFV_HAS_TIE_EARRING, ge) != 0;

   195

	bool has_glasses     = GetCompanyManagerFaceBits(cmf, CMFV_HAS_GLASSES, ge) != 0;

   196

   197

	if (!AreCompanyManagerFaceBitsValid(cmf, CMFV_EYE_COLOUR, ge)) return false;

   198

	for (CompanyManagerFaceVariable cmfv = CMFV_CHEEKS; cmfv < CMFV_END; cmfv++) {

   199

		switch (cmfv) {

   200

			case CMFV_MOUSTACHE:   if (!has_moustache)   continue; break;

   201

			case CMFV_LIPS:        /* FALL THROUGH */

   202

			case CMFV_NOSE:        if (has_moustache)    continue; break;

   203

			case CMFV_TIE_EARRING: if (!has_tie_earring) continue; break;

   204

			case CMFV_GLASSES:     if (!has_glasses)     continue; break;

   205

			default: break;

   206

		}

   207

		if (!AreCompanyManagerFaceBitsValid(cmf, cmfv, ge)) return false;

   208

	}

   209

   210

	return true;

   211

}

   212

   213

void InvalidateCompanyWindows(const Company *company)

   214

{

   215

	CompanyID cid = company->index;

   216

   217

	if (cid == _local_company) InvalidateWindow(WC_STATUS_BAR, 0);

   218

	InvalidateWindow(WC_FINANCES, cid);

   219

}

   220

   221

bool CheckCompanyHasMoney(CommandCost cost)

   222

{

   223

	if (cost.GetCost() > 0) {

   224

		CompanyID company = _current_company;

   225

		if (IsValidCompanyID(company) && cost.GetCost() > GetCompany(company)->money) {

   226

			SetDParam(0, cost.GetCost());

   227

			_error_message = STR_0003_NOT_ENOUGH_CASH_REQUIRES;

   228

			return false;

   229

		}

   230

	}

   231

	return true;

   232

}

   233

   234

static void SubtractMoneyFromAnyCompany(Company *c, CommandCost cost)

   235

{

   236

	if (cost.GetCost() == 0) return;

   237

	assert(cost.GetExpensesType() != INVALID_EXPENSES);

   238

   239

	c->money -= cost.GetCost();

   240

	c->yearly_expenses[0][cost.GetExpensesType()] += cost.GetCost();

   241

   242

	if (HasBit(1 << EXPENSES_TRAIN_INC    |

   243

	           1 << EXPENSES_ROADVEH_INC  |

   244

	           1 << EXPENSES_AIRCRAFT_INC |

   245

	           1 << EXPENSES_SHIP_INC, cost.GetExpensesType())) {

   246

		c->cur_economy.income -= cost.GetCost();

   247

	} else if (HasBit(1 << EXPENSES_TRAIN_RUN    |

   248

	                  1 << EXPENSES_ROADVEH_RUN  |

   249

	                  1 << EXPENSES_AIRCRAFT_RUN |

   250

	                  1 << EXPENSES_SHIP_RUN     |

   251

	                  1 << EXPENSES_PROPERTY     |

   252

	                  1 << EXPENSES_LOAN_INT, cost.GetExpensesType())) {

   253

		c->cur_economy.expenses -= cost.GetCost();

   254

	}

   255

   256

	InvalidateCompanyWindows(c);

   257

}

   258

   259

void SubtractMoneyFromCompany(CommandCost cost)

   260

{

   261

	CompanyID cid = _current_company;

   262

   263

	if (IsValidCompanyID(cid)) SubtractMoneyFromAnyCompany(GetCompany(cid), cost);

   264

}

   265

   266

void SubtractMoneyFromCompanyFract(CompanyID company, CommandCost cst)

   267

{

   268

	Company *c = GetCompany(company);

   269

	byte m = c->money_fraction;

   270

	Money cost = cst.GetCost();

   271

   272

	c->money_fraction = m - (byte)cost;

   273

	cost >>= 8;

   274

	if (c->money_fraction > m) cost++;

   275

	if (cost != 0) SubtractMoneyFromAnyCompany(c, CommandCost(cst.GetExpensesType(), cost));

   276

}

   277

   278

void GetNameOfOwner(Owner owner, TileIndex tile)

   279

{

   280

	SetDParam(2, owner);

   281

   282

	if (owner != OWNER_TOWN) {

   283

		if (!IsValidCompanyID(owner)) {

   284

			SetDParam(0, STR_0150_SOMEONE);

   285

		} else {

   286

			SetDParam(0, STR_COMPANY_NAME);

   287

			SetDParam(1, owner);

   288

		}

   289

	} else {

   290

		const Town *t = ClosestTownFromTile(tile, UINT_MAX);

   291

   292

		SetDParam(0, STR_TOWN);

   293

		SetDParam(1, t->index);

   294

	}

   295

}

   296

   297

   298

bool CheckOwnership(Owner owner)

   299

{

   300

	assert(owner < OWNER_END);

   301

   302

	if (owner == _current_company) return true;

   303

	_error_message = STR_013B_OWNED_BY;

   304

	GetNameOfOwner(owner, 0);

   305

	return false;

   306

}

   307

   308

bool CheckTileOwnership(TileIndex tile)

   309

{

   310

	Owner owner = GetTileOwner(tile);

   311

   312

	assert(owner < OWNER_END);

   313

   314

	if (owner == _current_company) return true;

   315

	_error_message = STR_013B_OWNED_BY;

   316

   317

	/* no need to get the name of the owner unless we're the local company (saves some time) */

   318

	if (IsLocalCompany()) GetNameOfOwner(owner, tile);

   319

	return false;

   320

}

   321

   322

static void GenerateCompanyName(Company *c)

   323

{

   324

	TileIndex tile;

   325

	Town *t;

   326

	StringID str;

   327

	Company *cc;

   328

	uint32 strp;

   329

	char buffer[100];

   330

   331

	if (c->name_1 != STR_SV_UNNAMED) return;

   332

   333

	tile = c->last_build_coordinate;

   334

	if (tile == 0) return;

   335

   336

	t = ClosestTownFromTile(tile, UINT_MAX);

   337

   338

	if (t->name == NULL && IsInsideMM(t->townnametype, SPECSTR_TOWNNAME_START, SPECSTR_TOWNNAME_LAST + 1)) {

   339

		str = t->townnametype - SPECSTR_TOWNNAME_START + SPECSTR_PLAYERNAME_START;

   340

		strp = t->townnameparts;

   341

   342

verify_name:;

   343

		/* No companies must have this name already */

   344

		FOR_ALL_COMPANIES(cc) {

   345

			if (cc->name_1 == str && cc->name_2 == strp) goto bad_town_name;

   346

		}

   347

   348

		GetString(buffer, str, lastof(buffer));

   349

		if (strlen(buffer) >= MAX_LENGTH_COMPANY_NAME_BYTES) goto bad_town_name;

   350

   351

set_name:;

   352

		c->name_1 = str;

   353

		c->name_2 = strp;

   354

   355

		MarkWholeScreenDirty();

   356

   357

		if (!IsHumanCompany(c->index)) {

   358

			CompanyNewsInformation *cni = MallocT<CompanyNewsInformation>(1);

   359

			cni->FillData(c);

   360

			SetDParam(0, STR_705E_NEW_TRANSPORT_COMPANY_LAUNCHED);

   361

			SetDParam(1, STR_705F_STARTS_CONSTRUCTION_NEAR);

   362

			SetDParamStr(2, cni->company_name);

   363

			SetDParam(3, t->index);

   364

			AddNewsItem(STR_02B6, NS_COMPANY_NEW, c->last_build_coordinate, 0, cni);

   365

		}

   366

		return;

   367

	}

   368

bad_town_name:;

   369

   370

	if (c->president_name_1 == SPECSTR_PRESIDENT_NAME) {

   371

		str = SPECSTR_ANDCO_NAME;

   372

		strp = c->president_name_2;

   373

		goto set_name;

   374

	} else {

   375

		str = SPECSTR_ANDCO_NAME;

   376

		strp = Random();

   377

		goto verify_name;

   378

	}

   379

}

   380

   381

static const byte _colour_sort[COLOUR_END] = {2, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 2, 3, 1, 1, 1};

   382

static const Colours _similar_colour[COLOUR_END][2] = {

   383

	{ COLOUR_BLUE,       COLOUR_LIGHT_BLUE }, // COLOUR_DARK_BLUE

   384

	{ COLOUR_GREEN,      COLOUR_DARK_GREEN }, // COLOUR_PALE_GREEN

   385

	{ INVALID_COLOUR,    INVALID_COLOUR    }, // COLOUR_PINK

   386

	{ COLOUR_ORANGE,     INVALID_COLOUR    }, // COLOUR_YELLOW

   387

	{ INVALID_COLOUR,    INVALID_COLOUR    }, // COLOUR_RED

   388

	{ COLOUR_DARK_BLUE,  COLOUR_BLUE       }, // COLOUR_LIGHT_BLUE

   389

	{ COLOUR_PALE_GREEN, COLOUR_DARK_GREEN }, // COLOUR_GREEN

   390

	{ COLOUR_PALE_GREEN, COLOUR_GREEN      }, // COLOUR_DARK_GREEN

   391

	{ COLOUR_DARK_BLUE,  COLOUR_LIGHT_BLUE }, // COLOUR_BLUE

   392

	{ COLOUR_BROWN,      COLOUR_ORANGE     }, // COLOUR_CREAM

   393

	{ COLOUR_PURPLE,     INVALID_COLOUR    }, // COLOUR_MAUVE

   394

	{ COLOUR_MAUVE,      INVALID_COLOUR    }, // COLOUR_PURPLE

   395

	{ COLOUR_YELLOW,     COLOUR_CREAM      }, // COLOUR_ORANGE

   396

	{ COLOUR_CREAM,      INVALID_COLOUR    }, // COLOUR_BROWN

   397

	{ COLOUR_WHITE,      INVALID_COLOUR    }, // COLOUR_GREY

   398

	{ COLOUR_GREY,       INVALID_COLOUR    }, // COLOUR_WHITE

   399

};

   400

   401

static byte GenerateCompanyColour()

   402

{

   403

	Colours colours[COLOUR_END];

   404

   405

	/* Initialize array */

   406

	for (uint i = 0; i < COLOUR_END; i++) colours[i] = (Colours)i;

   407

   408

	/* And randomize it */

   409

	for (uint i = 0; i < 100; i++) {

   410

		uint r = Random();

   411

		Swap(colours[GB(r, 0, 4)], colours[GB(r, 4, 4)]);

   412

	}

   413

   414

	/* Bubble sort it according to the values in table 1 */

   415

	for (uint i = 0; i < COLOUR_END; i++) {

   416

		for (uint j = 1; j < COLOUR_END; j++) {

   417

			if (_colour_sort[colours[j - 1]] < _colour_sort[colours[j]]) {

   418

				Swap(colours[j - 1], colours[j]);

   419

			}

   420

		}

   421

	};

   422

   423

	/* Move the colors that look similar to each company's color to the side */

   424

	Company *c;

   425

	FOR_ALL_COMPANIES(c) {

   426

		Colours pcolour = (Colours)c->colour;

   427

   428

		for (uint i = 0; i < COLOUR_END; i++) {

   429

			if (colours[i] == pcolour) {

   430

				colours[i] = INVALID_COLOUR;

   431

				break;

   432

			}

   433

		}

   434

   435

		for (uint j = 0; j < 2; j++) {

   436

			Colours similar = _similar_colour[pcolour][j];

   437

			if (similar == INVALID_COLOUR) break;

   438

   439

			for (uint i = 1; i < COLOUR_END; i++) {

   440

				if (colours[i - 1] == similar) Swap(colours[i - 1], colours[i]);

   441

			}

   442

		}

   443

	}

   444

   445

	/* Return the first available color */

   446

	for (uint i = 0; i < COLOUR_END; i++) {

   447

		if (colours[i] != INVALID_COLOUR) return colours[i];

   448

	}

   449

   450

	NOT_REACHED();

   451

}

   452

   453

static void GeneratePresidentName(Company *c)

   454

{

   455

	Company *cc;

   456

	char buffer[100], buffer2[40];

   457

   458

	for (;;) {

   459

restart:;

   460

   461

		c->president_name_2 = Random();

   462

		c->president_name_1 = SPECSTR_PRESIDENT_NAME;

   463

   464

		SetDParam(0, c->index);

   465

		GetString(buffer, STR_PRESIDENT_NAME, lastof(buffer));

   466

		if (strlen(buffer) >= 32 || GetStringBoundingBox(buffer).width >= 94)

   467

			continue;

   468

   469

		FOR_ALL_COMPANIES(cc) {

   470

			if (c != cc) {

   471

				SetDParam(0, cc->index);

   472

				GetString(buffer2, STR_PRESIDENT_NAME, lastof(buffer2));

   473

				if (strcmp(buffer2, buffer) == 0)

   474

					goto restart;

   475

			}

   476

		}

   477

		return;

   478

	}

   479

}

   480

   481

void ResetCompanyLivery(Company *c)

   482

{

   483

	for (LiveryScheme scheme = LS_BEGIN; scheme < LS_END; scheme++) {

   484

		c->livery[scheme].in_use  = false;

   485

		c->livery[scheme].colour1 = c->colour;