1

/* $Id$ */

     2

     3

/** @file ai.cpp Base for all AIs. */

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h"

     7

#include "../variables.h"

     8

#include "../command_func.h"

     9

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

    10

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

    11

#include "../player_func.h"

    12

#include "../player_base.h"

    13

#include "ai.h"

    14

#include "default/default.h"

    15

#include "trolly/trolly.h"

    16

#include "../signal_func.h"

    17

    18

AIStruct _ai;

    19

AIPlayer _ai_player[MAX_PLAYERS];

    20

    21

/**

    22

 * Dequeues commands put in the queue via AI_PutCommandInQueue.

    23

 */

    24

static void AI_DequeueCommands(PlayerID player)

    25

{

    26

	AICommand *com, *entry_com;

    27

    28

	entry_com = _ai_player[player].queue;

    29

    30

	/* It happens that DoCommandP issues a new DoCommandAI which adds a new command

    31

	 *  to this very same queue (don't argue about this, if it currently doesn't

    32

	 *  happen I can tell you it will happen with AIScript -- TrueLight). If we

    33

	 *  do not make the queue NULL, that commands will be dequeued immediatly.

    34

	 *  Therefor we safe the entry-point to entry_com, and make the queue NULL, so

    35

	 *  the new queue can be safely built up. */

    36

	_ai_player[player].queue = NULL;

    37

	_ai_player[player].queue_tail = NULL;

    38

    39

	/* Dequeue all commands */

    40

	while ((com = entry_com) != NULL) {

    41

		_current_player = player;

    42

    43

		_cmd_text = com->text;

    44

		DoCommandP(com->tile, com->p1, com->p2, com->callback, com->procc);

    45

    46

		/* Free item */

    47

		entry_com = com->next;

    48

		free(com->text);

    49

		free(com);

    50

	}

    51

}

    52

    53

/**

    54

 * Needed for SP; we need to delay DoCommand with 1 tick, because else events

    55

 *  will make infinite loops (AIScript).

    56

 */

    57

static void AI_PutCommandInQueue(PlayerID player, TileIndex tile, uint32 p1, uint32 p2, uint32 procc, CommandCallback* callback)

    58

{

    59

	AICommand *com;

    60

    61

	if (_ai_player[player].queue_tail == NULL) {

    62

		/* There is no item in the queue yet, create the queue */

    63

		_ai_player[player].queue = MallocT<AICommand>(1);

    64

		_ai_player[player].queue_tail = _ai_player[player].queue;

    65

	} else {

    66

		/* Add an item at the end */

    67

		_ai_player[player].queue_tail->next = MallocT<AICommand>(1);

    68

		_ai_player[player].queue_tail = _ai_player[player].queue_tail->next;

    69

	}

    70

    71

	/* This is our new item */

    72

	com = _ai_player[player].queue_tail;

    73

    74

	/* Assign the info */

    75

	com->tile  = tile;

    76

	com->p1    = p1;

    77

	com->p2    = p2;

    78

	com->procc = procc;

    79

	com->callback = callback;

    80

	com->next  = NULL;

    81

	com->text  = NULL;

    82

    83

	/* Copy the cmd_text, if needed */

    84

	if (_cmd_text != NULL) {

    85

		com->text = strdup(_cmd_text);

    86

		_cmd_text = NULL;

    87

	}

    88

}

    89

    90

/**

    91

 * Executes a raw DoCommand for the AI.

    92

 */

    93

CommandCost AI_DoCommandCc(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint32 procc, CommandCallback* callback)

    94

{

    95

	PlayerID old_lp;

    96

	CommandCost res;

    97

	const char* tmp_cmdtext;

    98

    99

	/* If you enable DC_EXEC with DC_QUERY_COST you are a really strange

   100

	 *   person.. should we check for those funny jokes?

   101

	 */

   102

   103

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

   104

	tmp_cmdtext = _cmd_text;

   105

   106

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

   107

	res = DoCommand(tile, p1, p2, flags & ~DC_EXEC, procc);

   108

	/* The command failed, or you didn't want to execute, or you are quering, return */

   109

	if (CmdFailed(res) || !(flags & DC_EXEC) || (flags & DC_QUERY_COST)) {

   110

		return res;

   111

	}

   112

   113

	/* Restore _cmd_text */

   114

	_cmd_text = tmp_cmdtext;

   115

   116

	/* NetworkSend_Command needs _local_player to be set correctly, so

   117

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

   118

	old_lp = _local_player;

   119

	_local_player = _current_player;

   120

   121

#ifdef ENABLE_NETWORK

   122

	/* Send the command */

   123

	if (_networking) {

   124

		/* Network is easy, send it to his handler */

   125

		NetworkSend_Command(tile, p1, p2, procc, callback);

   126

	} else {

   127

#else

   128

	{

   129

#endif

   130

		/* If we execute BuildCommands directly in SP, we have a big problem with events

   131

		 *  so we need to delay is for 1 tick */

   132

		AI_PutCommandInQueue(_current_player, tile, p1, p2, procc, callback);

   133

	}

   134

   135

	/* Set _local_player back */

   136

	_local_player = old_lp;

   137

   138

	return res;

   139

}

   140

   141

   142

CommandCost AI_DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint32 procc)

   143

{

   144

	return AI_DoCommandCc(tile, p1, p2, flags, procc, NULL);

   145

}

   146

   147

   148

/**

   149

 * Run 1 tick of the AI. Don't overdo it, keep it realistic.

   150

 */

   151

static void AI_RunTick(PlayerID player)

   152

{

   153

	extern void AiNewDoGameLoop(Player *p);

   154

   155

	Player *p = GetPlayer(player);

   156

	_current_player = player;

   157

   158

	if (_settings_game.ai.ainew_active) {

   159

		AiNewDoGameLoop(p);

   160

	} else {

   161

		/* Enable all kind of cheats the old AI needs in order to operate correctly... */

   162

		_is_old_ai_player = true;

   163

		AiDoGameLoop(p);

   164

		_is_old_ai_player = false;

   165

	}

   166

   167

	/* AI could change some track, so update signals */

   168

	UpdateSignalsInBuffer();

   169

}

   170

   171

   172

/**

   173

 * The gameloop for AIs.

   174

 *  Handles one tick for all the AIs.

   175

 */

   176

void AI_RunGameLoop()

   177

{

   178

	/* Don't do anything if ai is disabled */

   179

	if (!_ai.enabled) return;

   180

   181

	/* Don't do anything if we are a network-client, or the AI has been disabled */

   182

	if (_networking && (!_network_server || !_settings_game.ai.ai_in_multiplayer)) return;

   183

   184

	/* New tick */

   185

	_ai.tick++;

   186

   187

	/* Make sure the AI follows the difficulty rule.. */

   188

	assert(_settings_game.difficulty.competitor_speed <= 4);

   189

	if ((_ai.tick & ((1 << (4 - _settings_game.difficulty.competitor_speed)) - 1)) != 0) return;

   190

   191

	/* Check for AI-client (so joining a network with an AI) */

   192

	if (!_networking || _network_server) {

   193

		/* Check if we want to run AIs (server or SP only) */

   194

		const Player* p;

   195

   196

		FOR_ALL_PLAYERS(p) {

   197

			if (p->is_ai) {

   198

				/* This should always be true, else something went wrong... */

   199

				assert(_ai_player[p->index].active);

   200

   201

				/* Run the script */

   202

				AI_DequeueCommands(p->index);

   203

				AI_RunTick(p->index);

   204

			}

   205

		}

   206

	}

   207

   208

	_current_player = OWNER_NONE;

   209

}

   210

   211

/**

   212

 * A new AI sees the day of light. You can do here what ever you think is needed.

   213

 */

   214

void AI_StartNewAI(PlayerID player)

   215

{

   216

	assert(IsValidPlayerID(player));

   217

   218

	/* Called if a new AI is booted */

   219

	_ai_player[player].active = true;

   220

}

   221

   222

/**

   223

 * This AI player died. Give it some chance to make a final puf.

   224

 */

   225

void AI_PlayerDied(PlayerID player)

   226

{

   227

	/* Called if this AI died */

   228

	_ai_player[player].active = false;

   229

   230

	if (_players_ainew[player].pathfinder == NULL) return;

   231

   232

	AyStarMain_Free(_players_ainew[player].pathfinder);

   233

	delete _players_ainew[player].pathfinder;

   234

	_players_ainew[player].pathfinder = NULL;

   235

   236

}

   237

   238

/**

   239

 * Initialize some AI-related stuff.

   240

 */

   241

void AI_Initialize()

   242

{

   243

	/* First, make sure all AIs are DEAD! */

   244

	AI_Uninitialize();

   245

   246

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

   247

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

   248

   249

	_ai.enabled = true;

   250

}

   251

   252

/**

   253

 * Deinitializer for AI-related stuff.

   254

 */

   255

void AI_Uninitialize()

   256

{

   257

	for (PlayerID p = PLAYER_FIRST; p < MAX_PLAYERS; p++) AI_PlayerDied(p);

   258

}