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 "../../command_func.h"

    10

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

    11

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

    12

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

    13

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

    14

#include "../ai.h"

    15

#include "../ai_threads.h"

    16

    17

void AIObject::SetDoCommandDelay(uint ticks)

    18

{

    19

	assert(ticks > 0);

    20

	GetDoCommandStruct(_current_player)->delay = ticks;

    21

}

    22

    23

uint AIObject::GetDoCommandDelay()

    24

{

    25

	return GetDoCommandStruct(_current_player)->delay;

    26

}

    27

    28

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

    29

{

    30

	GetDoCommandStruct(_current_player)->mode = proc;

    31

	GetDoCommandStruct(_current_player)->mode_instance = instance;

    32

}

    33

    34

AIModeProc *AIObject::GetDoCommandMode()

    35

{

    36

	return GetDoCommandStruct(_current_player)->mode;

    37

}

    38

    39

AIObject *AIObject::GetDoCommandModeInstance()

    40

{

    41

	return GetDoCommandStruct(_current_player)->mode_instance;

    42

}

    43

    44

void AIObject::SetDoCommandCosts(Money value)

    45

{

    46

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

    47

}

    48

    49

void AIObject::IncreaseDoCommandCosts(Money value)

    50

{

    51

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

    52

}

    53

    54

Money AIObject::GetDoCommandCosts()

    55

{

    56

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

    57

}

    58

    59

void AIObject::SetLastError(AIErrorType last_error)

    60

{

    61

	GetDoCommandStruct(_current_player)->last_error = last_error;

    62

}

    63

    64

AIErrorType AIObject::GetLastError()

    65

{

    66

	return GetDoCommandStruct(_current_player)->last_error;

    67

}

    68

    69

void AIObject::SetLastCommandRes(bool res)

    70

{

    71

	GetDoCommandStruct(_current_player)->last_command_res = res;

    72

}

    73

    74

bool AIObject::GetLastCommandRes()

    75

{

    76

	return GetDoCommandStruct(_current_player)->last_command_res;

    77

}

    78

    79

void AIObject::SetNewVehicleID(VehicleID vehicle_id)

    80

{

    81

	GetDoCommandStruct(_current_player)->new_vehicle_id = vehicle_id;

    82

}

    83

    84

VehicleID AIObject::GetNewVehicleID()

    85

{

    86

	return GetDoCommandStruct(_current_player)->new_vehicle_id;

    87

}

    88

    89

void AIObject::SetNewSignID(SignID sign_id)

    90

{

    91

	GetDoCommandStruct(_current_player)->new_sign_id = sign_id;

    92

}

    93

    94

SignID AIObject::GetNewSignID()

    95

{

    96

	return GetDoCommandStruct(_current_player)->new_sign_id;

    97

}

    98

    99

void *&AIObject::GetEventPointer()

   100

{

   101

	return GetDoCommandStruct(_current_player)->event_data;

   102

}

   103

   104

void *&AIObject::GetLogPointer()

   105

{

   106

	return GetDoCommandStruct(_current_player)->log_data;

   107

}

   108

   109

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

   110

{

   111

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

   112

	static AIDoCommandStruct command_struct[MAX_PLAYERS];

   113

	static bool initialized = false;

   114

   115

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

   116

	if (!initialized) {

   117

		initialized = true;

   118

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

   119

	}

   120

   121

	return &command_struct[player];

   122

}

   123

   124

void AIObject::ResetInternalPlayerData()

   125

{

   126

	AIDoCommandStruct *command_struct = GetDoCommandStruct(_current_player);

   127

	command_struct->mode = NULL;

   128

	command_struct->delay = 1;

   129

	command_struct->costs = CommandCost();

   130

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

   131

	command_struct->event_data = NULL;

   132

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

   133

	command_struct->log_data = NULL;

   134

}

   135

   136

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

   137

{

   138

	uint32 flags = 0;

   139

	PlayerID old_lp;

   140

	CommandCost res;

   141

	const char *tmp_cmdtext;

   142

   143

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

   144

	SetLastError(AIError::ERR_NONE);

   145

   146

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

   147

	if (water_protection) flags |= DC_NO_WATER;

   148

   149

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

   150

	tmp_cmdtext = _cmd_text;

   151

   152

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

   153

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

   154

	/* The command failed, so return */

   155

	if (::CmdFailed(res)) {

   156

		SetLastError(AIError::StringToError(_error_message));

   157

		return false;

   158

	}

   159

   160

	/* Restore _cmd_text */

   161

	_cmd_text = tmp_cmdtext;

   162

   163

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

   164

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

   165

		IncreaseDoCommandCosts(res.GetCost());

   166

		return true;

   167

	}

   168

   169

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

   170

	 * over the network */

   171

	if (flags & DC_NO_WATER) procc |= CMD_NO_WATER;

   172

   173

#ifdef ENABLE_NETWORK

   174

	/* Send the command */

   175

	if (_networking) {

   176

		/* NetworkSend_Command needs _local_player to be set correctly, so

   177

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

   178

		old_lp = _local_player;

   179

		_local_player = _current_player;

   180

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

   181

		_local_player = old_lp;

   182

   183

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

   184

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

   185

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

   186

		if (!GetLastCommandRes()) res = CMD_ERROR;

   187

	} else {

   188

#else

   189

	{

   190

#endif

   191

		/* For SinglePlayer we execute the command immediatly */

   192

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

   193

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

   194

		SetNewVehicleID(_new_vehicle_id);

   195

		SetNewSignID(_new_sign_id);

   196

   197

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

   198

		::AI_SuspendPlayer(_current_player, GetDoCommandDelay());

   199

	}

   200

   201

	if (::CmdFailed(res)) {

   202

		SetLastError(AIError::StringToError(_error_message));

   203

		return false;

   204

	}

   205

   206

	IncreaseDoCommandCosts(res.GetCost());

   207

	return true;

   208

}