1

/* $Id$ */

     2

     3

/** @file ai_company.cpp Implementation of AICompany. */

     4

     5

#include "ai_company.hpp"

     6

#include "ai_error.hpp"

     7

#include "../../openttd.h"

     8

#include "../../command_func.h"

     9

#include "../../player_func.h"

    10

#include "../../player_base.h"

    11

#include "../../economy_func.h"

    12

#include "../../strings_func.h"

    13

#include "../../tile_map.h"

    14

#include "../../variables.h"

    15

#include "../../core/alloc_func.hpp"

    16

#include "../../string_func.h"

    17

#include "table/strings.h"

    18

    19

/* static */ AICompany::CompanyID AICompany::ResolveCompanyID(AICompany::CompanyID company)

    20

{

    21

	if (company == MY_COMPANY) return (CompanyID)((byte)_current_player);

    22

    23

	return (::IsValidPlayer((PlayerID)company) && ::GetPlayer((PlayerID)company)->is_active) ? company : INVALID_COMPANY;

    24

}

    25

    26

/* static */ bool AICompany::IsMine(AICompany::CompanyID company)

    27

{

    28

	return ResolveCompanyID(company) == ResolveCompanyID(MY_COMPANY);

    29

}

    30

    31

/* static */ bool AICompany::SetCompanyName(const char *name)

    32

{

    33

	EnforcePrecondition(false, !::StrEmpty(name));

    34

    35

	_cmd_text = name;

    36

	return AIObject::DoCommand(0, 0, 0, CMD_CHANGE_COMPANY_NAME);

    37

}

    38

    39

/* static */ char *AICompany::GetCompanyName(AICompany::CompanyID company)

    40

{

    41

	company = ResolveCompanyID(company);

    42

	if (company == INVALID_COMPANY) return NULL;

    43

    44

	static const int len = 64;

    45

	char *company_name = MallocT<char>(len);

    46

    47

	::SetDParam(0, GetPlayer((PlayerID)company)->index);

    48

	::GetString(company_name, STR_COMPANY_NAME, &company_name[len - 1]);

    49

	return company_name;

    50

}

    51

    52

/* static */ bool AICompany::SetPresidentName(const char *name)

    53

{

    54

	EnforcePrecondition(false, !::StrEmpty(name));

    55

    56

	_cmd_text = name;

    57

	return AIObject::DoCommand(0, 0, 0, CMD_CHANGE_PRESIDENT_NAME);

    58

}

    59

    60

/* static */ char *AICompany::GetPresidentName(AICompany::CompanyID company)

    61

{

    62

	company = ResolveCompanyID(company);

    63

    64

	static const int len = 64;

    65

	char *president_name = MallocT<char>(len);

    66

	if (company != INVALID_COMPANY) {

    67

		::SetDParam(0, GetPlayer((PlayerID)company)->index);

    68

		::GetString(president_name, STR_PLAYER_NAME, &president_name[len - 1]);

    69

	} else {

    70

		*president_name = '\0';

    71

	}

    72

    73

	return president_name;

    74

}

    75

    76

/* static */ Money AICompany::GetCompanyValue(AICompany::CompanyID company)

    77

{

    78

	company = ResolveCompanyID(company);

    79

	if (company == INVALID_COMPANY) return -1;

    80

    81

	return ::GetPlayer((PlayerID)company)->cur_economy.company_value;

    82

}

    83

    84

/* static */ Money AICompany::GetBankBalance(AICompany::CompanyID company)

    85

{

    86

	company = ResolveCompanyID(company);

    87

	if (company == INVALID_COMPANY) return -1;

    88

    89

	return ::GetPlayer((PlayerID)company)->player_money;

    90

}

    91

    92

/* static */ Money AICompany::GetLoanAmount()

    93

{

    94

	return ::GetPlayer(_current_player)->current_loan;

    95

}

    96

    97

/* static */ Money AICompany::GetMaxLoanAmount()

    98

{

    99

	return _economy.max_loan;

   100

}

   101

   102

/* static */ Money AICompany::GetLoanInterval()

   103

{

   104

	return LOAN_INTERVAL;

   105

}

   106

   107

/* static */ bool AICompany::SetLoanAmount(int32 loan)

   108

{

   109

	EnforcePrecondition(false, loan >= 0);

   110

	EnforcePrecondition(false, (loan % GetLoanInterval()) == 0);

   111

	EnforcePrecondition(false, loan <= GetMaxLoanAmount());

   112

	EnforcePrecondition(false, (loan - GetLoanAmount() + GetBankBalance(MY_COMPANY)) >= 0);

   113

   114

	if (loan == GetLoanAmount()) return true;

   115

   116

	return AIObject::DoCommand(0,

   117

			abs(loan - GetLoanAmount()), 2,

   118

			(loan > GetLoanAmount()) ? CMD_INCREASE_LOAN : CMD_DECREASE_LOAN);

   119

}

   120

   121

/* static */ bool AICompany::SetMinimumLoanAmount(int32 loan)

   122

{

   123

	EnforcePrecondition(false, loan >= 0);

   124

   125

	int32 over_interval = loan % GetLoanInterval();

   126

	if (over_interval != 0) loan += GetLoanInterval() - over_interval;

   127

   128

	EnforcePrecondition(false, loan <= GetMaxLoanAmount());

   129

   130

	SetLoanAmount(loan);

   131

   132

	return GetLoanAmount() == loan;

   133

}

   134

   135

/* static */ bool AICompany::BuildCompanyHQ(TileIndex tile)

   136

{

   137

	EnforcePrecondition(false, ::IsValidTile(tile));

   138

   139

	return AIObject::DoCommand(tile, 0, 0, CMD_BUILD_COMPANY_HQ);

   140

}

   141

   142

/* static */ TileIndex AICompany::GetCompanyHQ(CompanyID company)

   143

{

   144

	company = ResolveCompanyID(company);

   145

	if (company == INVALID_COMPANY) return INVALID_TILE;

   146

   147

	TileIndex loc = ::GetPlayer((PlayerID)company)->location_of_house;

   148

	return (loc == 0) ? INVALID_TILE : loc;

   149

}

   150

   151

/* static */ bool AICompany::SetAutoRenewStatus(bool autorenew)

   152

{

   153

	return AIObject::DoCommand(0, 0, autorenew ? 1 : 0, CMD_SET_AUTOREPLACE);

   154

}

   155

   156

/* static */ bool AICompany::GetAutoRenewStatus(CompanyID company)

   157

{

   158

	company = ResolveCompanyID(company);

   159

	if (company == INVALID_COMPANY) return false;

   160

   161

	return ::GetPlayer((PlayerID)company)->engine_renew;

   162

}

   163

   164

/* static */ bool AICompany::SetAutoRenewMonths(int16 months)

   165

{

   166

	return AIObject::DoCommand(0, 1, months, CMD_SET_AUTOREPLACE);

   167

}

   168

   169

/* static */ int16 AICompany::GetAutoRenewMonths(CompanyID company)

   170

{

   171

	company = ResolveCompanyID(company);

   172

	if (company == INVALID_COMPANY) return 0;

   173

   174

	return ::GetPlayer((PlayerID)company)->engine_renew_months;

   175

}

   176

   177

/* static */ bool AICompany::SetAutoRenewMoney(uint32 money)

   178

{

   179

	return AIObject::DoCommand(0, 2, money, CMD_SET_AUTOREPLACE);

   180

}

   181

   182

/* static */ uint32 AICompany::GetAutoRenewMoney(CompanyID company)

   183

{

   184

	company = ResolveCompanyID(company);

   185

	if (company == INVALID_COMPANY) return 0;

   186

   187

	return ::GetPlayer((PlayerID)company)->engine_renew_money;

   188

}