1

/* $Id$ */

     2

     3

/** @file ai_object.cpp Implementation of AIObject. */

     4

     5

#include "ai_object.hpp"

     6

#include "ai_log.hpp"

     7

#include "ai_error.hpp"

     8

#include "table/strings.h"

     9

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

    10

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

    12

#include "../../network/network.h"

    13

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

    14

#include "../../signs_func.h"

    16

#include "../../vehicle_func.h"

    17

#include "../ai.h"

    18

#include "../ai_threads.h"

    19

    20

struct AIObject::AIDoCommandStruct {

    21

	AIModeProc *mode;

    22

	AIObject *mode_instance;

    23

	uint delay;

    24

	CommandCost costs;

    25

	uint last_error;

    26

	bool last_command_res;

    27

	VehicleID new_vehicle_id;

    28

	SignID new_sign_id;

    30

	RoadType road_type;

    31

	void *event_data;

    32

	void *log_data;

    33

};

    34

    35

void AIObject::SetDoCommandDelay(uint ticks)

    36

{

    37

	assert(ticks > 0);

    38

	GetDoCommandStruct(_current_player)->delay = ticks;

    39

}

    40

    41

uint AIObject::GetDoCommandDelay()

    42

{

    43

	return GetDoCommandStruct(_current_player)->delay;

    44

}

    45

    46

void AIObject::SetDoCommandMode(AIModeProc *proc, AIObject *instance)

    47

{

    48

	GetDoCommandStruct(_current_player)->mode = proc;

    49

	GetDoCommandStruct(_current_player)->mode_instance = instance;

    50

}

    51

    52

AIModeProc *AIObject::GetDoCommandMode()

    53

{

    54

	return GetDoCommandStruct(_current_player)->mode;

    55

}

    56

    57

AIObject *AIObject::GetDoCommandModeInstance()

    58

{

    59

	return GetDoCommandStruct(_current_player)->mode_instance;

    60

}

    61

    62

void AIObject::SetDoCommandCosts(Money value)

    63

{

    64

	GetDoCommandStruct(_current_player)->costs = CommandCost(value);

    65

}

    66

    67

void AIObject::IncreaseDoCommandCosts(Money value)

    68

{

    69

	GetDoCommandStruct(_current_player)->costs.AddCost(value);

    70

}

    71

    72

Money AIObject::GetDoCommandCosts()

    73

{

    74

	return GetDoCommandStruct(_current_player)->costs.GetCost();

    75

}

    76

    77

void AIObject::SetLastError(AIErrorType last_error)

    78

{

    79

	GetDoCommandStruct(_current_player)->last_error = last_error;

    80

}

    81

    82

AIErrorType AIObject::GetLastError()

    83

{

    84

	return GetDoCommandStruct(_current_player)->last_error;

    85

}

    86

    87

void AIObject::SetRoadType(RoadType road_type)

    88

{

    89

	GetDoCommandStruct(_current_player)->road_type = road_type;

    90

}

    91

    92

RoadType AIObject::GetRoadType()

    93

{

    94

	return GetDoCommandStruct(_current_player)->road_type;

    95

}

    96

    97

void AIObject::SetLastCommandRes(bool res)

    98

{

    99

	GetDoCommandStruct(_current_player)->last_command_res = res;

   100

}

   101

   102

bool AIObject::GetLastCommandRes()

   103

{

   104

	return GetDoCommandStruct(_current_player)->last_command_res;

   105

}

   106

   107

void AIObject::SetNewVehicleID(VehicleID vehicle_id)

   108

{

   109

	GetDoCommandStruct(_current_player)->new_vehicle_id = vehicle_id;

   110

}

   111

   112

VehicleID AIObject::GetNewVehicleID()

   113

{

   114

	return GetDoCommandStruct(_current_player)->new_vehicle_id;

   115

}

   116

   117

void AIObject::SetNewSignID(SignID sign_id)

   118

{

   119

	GetDoCommandStruct(_current_player)->new_sign_id = sign_id;

   120

}

   121

   122

SignID AIObject::GetNewSignID()

   123

{

   124

	return GetDoCommandStruct(_current_player)->new_sign_id;

   125

}

   126

   137

void *&AIObject::GetEventPointer()

   138

{

   139

	return GetDoCommandStruct(_current_player)->event_data;

   140

}

   141

   142

void *&AIObject::GetLogPointer()

   143

{

   144

	return GetDoCommandStruct(_current_player)->log_data;

   145

}

   146

   147

AIObject::AIDoCommandStruct *AIObject::GetDoCommandStruct(PlayerID player)

   148

{

   149

	/* Storage for data on per-AI level */

   150

	static AIDoCommandStruct command_struct[MAX_PLAYERS];

   151

	static bool initialized = false;

   152

   153

	/* Make sure all memory is NULL when we start */

   154

	if (!initialized) {

   155

		initialized = true;

   156

		memset(&command_struct, 0, sizeof(command_struct));

   157

	}

   158

   159

	return &command_struct[player];

   160

}

   161

   162

void AIObject::ResetInternalPlayerData()

   163

{

   164

	AIDoCommandStruct *command_struct = GetDoCommandStruct(_current_player);

   165

	command_struct->mode = NULL;

   166

	command_struct->delay = 1;

   167

	command_struct->costs = CommandCost();

   168

	if (command_struct->event_data != NULL) AIEventController::FreeEventPointer();

   169

	command_struct->event_data = NULL;

   170

	if (command_struct->log_data != NULL) AILog::FreeLogPointer();

   171

	command_struct->log_data = NULL;

   172

}

   173

   174

bool AIObject::DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint procc, bool water_protection)

   175

{

   176

	uint32 flags = 0;

   177

	PlayerID old_lp;

   178

	CommandCost res;

   179

	const char *tmp_cmdtext;

   180

   181

	/* Make sure the last error is reset, so we don't give faulty warnings */

   182

	SetLastError(AIError::ERR_NONE);

   183

   184

	if (procc != CMD_LANDSCAPE_CLEAR) flags |= DC_AUTO;

   185

	if (water_protection) flags |= DC_NO_WATER;

   186

   187

	/* The test already resets _cmd_text, so backup the pointer */

   188

	tmp_cmdtext = _cmd_text;

   189

   190

	/* First, do a test-run to see if we can do this */

   191

	res = ::DoCommand(tile, p1, p2, flags, procc);

   192

	/* The command failed, so return */

   193

	if (::CmdFailed(res)) {

   194

		SetLastError(AIError::StringToError(_error_message));

   195

		return false;

   196

	}

   197

   198

	/* Restore _cmd_text */

   199

	_cmd_text = tmp_cmdtext;

   200

   201

	/* Check what the callback wants us to do */

   202

	if (GetDoCommandMode() != NULL && !GetDoCommandMode()(tile, p1, p2, procc, res)) {

   203

		IncreaseDoCommandCosts(res.GetCost());

   204

		return true;

   205

	}

   206

   207

	/* If we did a DC_EXEC, and the command did not return an error, execute it

   208

	 * over the network */

   209

	if (flags & DC_NO_WATER) procc |= CMD_NO_WATER;

   210

   211

#ifdef ENABLE_NETWORK

   212

	/* Send the command */

   213

	if (_networking) {

   214

		/* NetworkSend_Command needs _local_player to be set correctly, so

   215

		 * adjust it, and put it back right after the function */

   216

		old_lp = _local_player;

   217

		_local_player = _current_player;

   218

		::NetworkSend_Command(tile, p1, p2, procc, CcAI);

   219

		_local_player = old_lp;

   220

   221

		/* Suspend the AI till the command is really executed */

   222

		::AI_SuspendPlayer(_current_player, -(int)GetDoCommandDelay());

   223

		/* Check if the callback still agrees with us, else return error */

   224

		if (!GetLastCommandRes()) res = CMD_ERROR;

   225

	} else {

   226

#else

   227

	{

   228

#endif

   229

		/* For SinglePlayer we execute the command immediatly */

   230

		::DoCommandP(tile, p1, p2, NULL, procc);

   231

		/* Store some values inside the AIObject static memory */

   232

		SetNewVehicleID(_new_vehicle_id);

   233

		SetNewSignID(_new_sign_id);

   235

   236

		/* Suspend the AI player for 1 tick, so it simulates MultiPlayer */

   237

		::AI_SuspendPlayer(_current_player, GetDoCommandDelay());

   238

	}

   239

   240

	if (::CmdFailed(res)) {

   241

		SetLastError(AIError::StringToError(_error_message));

   242

		return false;

   243

	}

   244

   245

	IncreaseDoCommandCosts(res.GetCost());

   246

	return true;

   247

}