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"

    11

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

    12

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

    13

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

    14

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

    15

#include "../ai.h"

    16

#include "../ai_threads.h"

    17

    18

struct AIObject::AIDoCommandStruct {

    19

	AIModeProc *mode;

    20

	AIObject *mode_instance;

    21

	uint delay;

    22

	CommandCost costs;

    23

	uint last_error;

    24

	bool last_command_res;

    25

	VehicleID new_vehicle_id;

    26

	SignID new_sign_id;

    27

	void *event_data;

    28

	void *log_data;

    29

};

    30

    31

void AIObject::SetDoCommandDelay(uint ticks)

    32

{

    33

	assert(ticks > 0);

    34

	GetDoCommandStruct(_current_player)->delay = ticks;

    35

}

    36

    37

uint AIObject::GetDoCommandDelay()

    38

{

    39

	return GetDoCommandStruct(_current_player)->delay;

    40

}

    41

    42

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

    43

{

    44

	GetDoCommandStruct(_current_player)->mode = proc;

    45

	GetDoCommandStruct(_current_player)->mode_instance = instance;

    46

}

    47

    48

AIModeProc *AIObject::GetDoCommandMode()

    49

{

    50

	return GetDoCommandStruct(_current_player)->mode;

    51

}

    52

    53

AIObject *AIObject::GetDoCommandModeInstance()

    54

{

    55

	return GetDoCommandStruct(_current_player)->mode_instance;

    56

}

    57

    58

void AIObject::SetDoCommandCosts(Money value)

    59

{

    60

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

    61

}

    62

    63

void AIObject::IncreaseDoCommandCosts(Money value)

    64

{

    65

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

    66

}

    67

    68

Money AIObject::GetDoCommandCosts()

    69

{

    70

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

    71

}

    72

    73

void AIObject::SetLastError(AIErrorType last_error)

    74

{

    75

	GetDoCommandStruct(_current_player)->last_error = last_error;

    76

}

    77

    78

AIErrorType AIObject::GetLastError()

    79

{

    80

	return GetDoCommandStruct(_current_player)->last_error;

    81

}

    82

    83

void AIObject::SetLastCommandRes(bool res)

    84

{

    85

	GetDoCommandStruct(_current_player)->last_command_res = res;

    86

}

    87

    88

bool AIObject::GetLastCommandRes()

    89

{

    90

	return GetDoCommandStruct(_current_player)->last_command_res;

    91

}

    92

    93

void AIObject::SetNewVehicleID(VehicleID vehicle_id)

    94

{

    95

	GetDoCommandStruct(_current_player)->new_vehicle_id = vehicle_id;

    96

}

    97

    98

VehicleID AIObject::GetNewVehicleID()

    99

{

   100

	return GetDoCommandStruct(_current_player)->new_vehicle_id;

   101

}

   102

   103

void AIObject::SetNewSignID(SignID sign_id)

   104

{

   105

	GetDoCommandStruct(_current_player)->new_sign_id = sign_id;

   106

}

   107

   108

SignID AIObject::GetNewSignID()

   109

{

   110

	return GetDoCommandStruct(_current_player)->new_sign_id;

   111

}

   112

   113

void *&AIObject::GetEventPointer()

   114

{

   115

	return GetDoCommandStruct(_current_player)->event_data;

   116

}

   117

   118

void *&AIObject::GetLogPointer()

   119

{

   120

	return GetDoCommandStruct(_current_player)->log_data;

   121

}

   122

   123

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

   124

{

   125

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

   126

	static AIDoCommandStruct command_struct[MAX_PLAYERS];

   127

	static bool initialized = false;

   128

   129

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

   130

	if (!initialized) {

   131

		initialized = true;

   132

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

   133

	}

   134

   135

	return &command_struct[player];

   136

}

   137

   138

void AIObject::ResetInternalPlayerData()

   139

{

   140

	AIDoCommandStruct *command_struct = GetDoCommandStruct(_current_player);

   141

	command_struct->mode = NULL;

   142

	command_struct->delay = 1;

   143

	command_struct->costs = CommandCost();

   144

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

   145

	command_struct->event_data = NULL;

   146

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

   147

	command_struct->log_data = NULL;

   148

}

   149

   150

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

   151

{

   152

	uint32 flags = 0;

   153

	PlayerID old_lp;

   154

	CommandCost res;

   155

	const char *tmp_cmdtext;

   156

   157

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

   158

	SetLastError(AIError::ERR_NONE);

   159

   160

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

   161

	if (water_protection) flags |= DC_NO_WATER;

   162

   163

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

   164

	tmp_cmdtext = _cmd_text;

   165

   166

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

   167

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

   168

	/* The command failed, so return */

   169

	if (::CmdFailed(res)) {

   170

		SetLastError(AIError::StringToError(_error_message));

   171

		return false;

   172

	}

   173

   174

	/* Restore _cmd_text */

   175

	_cmd_text = tmp_cmdtext;

   176

   177

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

   178

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

   179

		IncreaseDoCommandCosts(res.GetCost());

   180

		return true;

   181

	}

   182

   183

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

   184

	 * over the network */

   185

	if (flags & DC_NO_WATER) procc |= CMD_NO_WATER;

   186

   187

#ifdef ENABLE_NETWORK

   188

	/* Send the command */

   189

	if (_networking) {

   190

		/* NetworkSend_Command needs _local_player to be set correctly, so

   191

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

   192

		old_lp = _local_player;

   193

		_local_player = _current_player;

   194

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

   195

		_local_player = old_lp;

   196

   197

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

   198

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

   199

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

   200

		if (!GetLastCommandRes()) res = CMD_ERROR;

   201

	} else {

   202

#else

   203

	{

   204

#endif

   205

		/* For SinglePlayer we execute the command immediatly */

   206

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

   207

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

   208

		SetNewVehicleID(_new_vehicle_id);

   209

		SetNewSignID(_new_sign_id);

   210

   211

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

   212

		::AI_SuspendPlayer(_current_player, GetDoCommandDelay());

   213

	}

   214

   215

	if (::CmdFailed(res)) {

   216

		SetLastError(AIError::StringToError(_error_message));

   217

		return false;

   218

	}

   219

   220

	IncreaseDoCommandCosts(res.GetCost());

   221

	return true;

   222

}