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

    16

    17

AIStruct _ai;

    18

AIPlayer _ai_player[MAX_PLAYERS];

    19

    20

/**

    21

 * Dequeues commands put in the queue via AI_PutCommandInQueue.

    22

 */

    23

static void AI_DequeueCommands(PlayerID player)

    24

{

    25

	AICommand *com, *entry_com;

    26

    27

	entry_com = _ai_player[player].queue;

    28

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

	_ai_player[player].queue = NULL;

    36

	_ai_player[player].queue_tail = NULL;

    37

    38

	/* Dequeue all commands */

    39

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

    40

		_current_player = player;

    41

    42

		_cmd_text = com->text;

    43

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

    44

    45

		/* Free item */

    46

		entry_com = com->next;

    47

		free(com->text);

    48

		free(com);

    49

	}

    50

}

    51

    52

/**

    53

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

    54

 *  will make infinite loops (AIScript).

    55

 */

    56

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

    57

{

    58

	AICommand *com;

    59

    60

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

    61

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

    62

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

    63

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

    64

	} else {

    65

		/* Add an item at the end */

    66

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

    67

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

    68

	}

    69

    70

	/* This is our new item */

    71

	com = _ai_player[player].queue_tail;

    72

    73

	/* Assign the info */

    74

	com->tile  = tile;

    75

	com->p1    = p1;

    76

	com->p2    = p2;

    77

	com->procc = procc;

    78

	com->callback = callback;

    79

	com->next  = NULL;

    80

	com->text  = NULL;

    81

    82

	/* Copy the cmd_text, if needed */

    83

	if (_cmd_text != NULL) {

    84

		com->text = strdup(_cmd_text);

    85

		_cmd_text = NULL;

    86

	}

    87

}

    88

    89

/**

    90

 * Executes a raw DoCommand for the AI.

    91

 */

    92

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

    93

{

    94

	PlayerID old_lp;

    95

	CommandCost res;

    96

	const char* tmp_cmdtext;

    97

    98

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

    99

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

   100

	 */

   101

   102

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

   103

	tmp_cmdtext = _cmd_text;

   104

   105

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

   106

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

   107

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

   108

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

   109

		return res;

   110

	}

   111

   112

	/* Restore _cmd_text */

   113

	_cmd_text = tmp_cmdtext;

   114

   115

	/* NetworkSend_Command needs _local_player to be set correctly, so

   116

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

   117

	old_lp = _local_player;

   118

	_local_player = _current_player;

   119

   120

#ifdef ENABLE_NETWORK

   121

	/* Send the command */

   122

	if (_networking) {

   123

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

   124

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

   125

	} else {

   126

#else

   127

	{

   128

#endif

   129

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

   130

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

   131

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

   132

	}

   133

   134

	/* Set _local_player back */

   135

	_local_player = old_lp;

   136

   137

	return res;

   138

}

   139

   140

   141

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

   142

{

   143

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

   144

}

   145

   146

   147

/**

   148

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

   149

 */

   150

static void AI_RunTick(PlayerID player)

   151

{

   152

	extern void AiNewDoGameLoop(Player *p);

   153

   154

	Player *p = GetPlayer(player);

   155

	_current_player = player;

   156

   157

	if (_settings_game.ai.ainew_active) {

   158

		AiNewDoGameLoop(p);

   159

	} else {

   160

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

   161

		_is_old_ai_player = true;

   162

		AiDoGameLoop(p);

   163

		_is_old_ai_player = false;

   164

	}

   165

   166

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

   167

	UpdateSignalsInBuffer();

   168

}

   169

   170

   171

/**

   172

 * The gameloop for AIs.

   173

 *  Handles one tick for all the AIs.

   174

 */

   175

void AI_RunGameLoop()

   176

{

   177

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

   178

	if (!_ai.enabled) return;

   179

   180

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

   181

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

   182

   183

	/* New tick */

   184

	_ai.tick++;

   185

   186

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

   187

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

   188

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

   189

   190

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

   191

	if (!_networking || _network_server) {

   192

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

   193

		const Player* p;

   194

   195

		FOR_ALL_PLAYERS(p) {

   196

			if (p->is_active && p->is_ai) {

   197

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

   198

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

   199

   200

				/* Run the script */

   201

				AI_DequeueCommands(p->index);

   202

				AI_RunTick(p->index);

   203

			}

   204

		}

   205

	}

   206

   207

	_current_player = OWNER_NONE;

   208

}

   209

   210

/**

   211

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

   212

 */

   213

void AI_StartNewAI(PlayerID player)

   214

{

   215

	assert(IsValidPlayer(player));

   216

   217

	/* Called if a new AI is booted */

   218

	_ai_player[player].active = true;

   219

}

   220

   221

/**

   222

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

   223

 */

   224

void AI_PlayerDied(PlayerID player)

   225

{

   226

	/* Called if this AI died */

   227

	_ai_player[player].active = false;

   228

}

   229

   230

/**

   231

 * Initialize some AI-related stuff.

   232

 */

   233

void AI_Initialize()

   234

{

   235

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

   236

	AI_Uninitialize();

   237

   238

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

   239

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

   240

   241

	_ai.enabled = true;

   242

}

   243

   244

/**

   245

 * Deinitializer for AI-related stuff.

   246

 */

   247

void AI_Uninitialize()

   248

{

   249

	const Player* p;

   250

   251

	FOR_ALL_PLAYERS(p) {

   252

		if (p->is_active && p->is_ai) AI_PlayerDied(p->index);

   253

	}

   254

}