1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../openttd.h"

     5

#include "../variables.h"

     6

#include "../command.h"

     7

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

     8

#include "../helpers.hpp"

     9

#include "ai.h"

    10

#include "default/default.h"

    11

    12

/**

    13

 * Dequeues commands put in the queue via AI_PutCommandInQueue.

    14

 */

    15

static void AI_DequeueCommands(PlayerID player)

    16

{

    17

	AICommand *com, *entry_com;

    18

    19

	entry_com = _ai_player[player].queue;

    20

    21

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

    22

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

    23

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

    24

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

    25

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

    26

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

    27

	_ai_player[player].queue = NULL;

    28

	_ai_player[player].queue_tail = NULL;

    29

    30

	/* Dequeue all commands */

    31

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

    32

		_current_player = player;

    33

    34

		_cmd_text = com->text;

    35

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

    36

    37

		/* Free item */

    38

		entry_com = com->next;

    39

		free(com->text);

    40

		free(com);

    41

	}

    42

}

    43

    44

/**

    45

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

    46

 *  will make infinite loops (AIScript).

    47

 */

    48

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

    49

{

    50

	AICommand *com;

    51

    52

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

    53

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

    54

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

    55

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

    56

	} else {

    57

		/* Add an item at the end */

    58

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

    59

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

    60

	}

    61

    62

	/* This is our new item */

    63

	com = _ai_player[player].queue_tail;

    64

    65

	/* Assign the info */

    66

	com->tile  = tile;

    67

	com->p1    = p1;

    68

	com->p2    = p2;

    69

	com->procc = procc;

    70

	com->callback = callback;

    71

	com->next  = NULL;

    72

	com->text  = NULL;

    73

    74

	/* Copy the cmd_text, if needed */

    75

	if (_cmd_text != NULL) {

    76

		com->text = strdup(_cmd_text);

    77

		_cmd_text = NULL;

    78

	}

    79

}

    80

    81

/**

    82

 * Executes a raw DoCommand for the AI.

    83

 */

    85

{

    86

	PlayerID old_lp;

    88

	const char* tmp_cmdtext;

    89

    90

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

    91

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

    92

	 */

    93

    94

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

    95

	tmp_cmdtext = _cmd_text;

    96

    97

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

    98

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

    99

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

   100

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

   101

		return res;

   102

	}

   103

   104

	/* Restore _cmd_text */

   105

	_cmd_text = tmp_cmdtext;

   106

   107

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

   108

	 * over the network */

   109

	if (flags & DC_AUTO)     procc |= CMD_AUTO;

   110

	if (flags & DC_NO_WATER) procc |= CMD_NO_WATER;

   111

   112

	/* NetworkSend_Command needs _local_player to be set correctly, so

   113

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

   114

	old_lp = _local_player;

   115

	_local_player = _current_player;

   116

   117

#ifdef ENABLE_NETWORK

   118

	/* Send the command */

   119

	if (_networking) {

   120

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

   121

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

   122

	} else {

   123

#else

   124

	{

   125

#endif

   126

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

   127

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

   128

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

   129

	}

   130

   131

	/* Set _local_player back */

   132

	_local_player = old_lp;

   133

   134

	return res;

   135

}

   136

   137

   139

{

   140

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

   141

}

   142

   143

   144

/**

   145

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

   146

 */

   147

static void AI_RunTick(PlayerID player)

   148

{

   149

	extern void AiNewDoGameLoop(Player *p);

   150

   151

	Player *p = GetPlayer(player);

   152

	_current_player = player;

   153

   154

	if (_patches.ainew_active) {

   155

		AiNewDoGameLoop(p);

   156

	} else {

   157

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

   158

		_is_old_ai_player = true;

   159

		AiDoGameLoop(p);

   160

		_is_old_ai_player = false;

   161

	}

   162

}

   163

   164

   165

/**

   166

 * The gameloop for AIs.

   167

 *  Handles one tick for all the AIs.

   168

 */

   169

void AI_RunGameLoop()

   170

{

   171

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

   172

	if (!_ai.enabled) return;

   173

   174

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

   175

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

   176

   177

	/* New tick */

   178

	_ai.tick++;

   179

   180

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

   181

	assert(_opt.diff.competitor_speed <= 4);

   182

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

   183

   184

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

   185

	if (!_networking || _network_server) {

   186

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

   187

		const Player* p;

   188

   189

		FOR_ALL_PLAYERS(p) {

   190

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

   191

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

   192

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

   193

   194

				/* Run the script */

   195

				AI_DequeueCommands(p->index);

   196

				AI_RunTick(p->index);

   197

			}

   198

		}

   199

	}

   200

   201

	_current_player = OWNER_NONE;

   202

}

   203

   204

/**

   205

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

   206

 */

   207

void AI_StartNewAI(PlayerID player)

   208

{

   209

	assert(IsValidPlayer(player));

   210

   211

	/* Called if a new AI is booted */

   212

	_ai_player[player].active = true;

   213

}

   214

   215

/**

   216

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

   217

 */

   218

void AI_PlayerDied(PlayerID player)

   219

{

   220

	/* Called if this AI died */

   221

	_ai_player[player].active = false;

   222

}

   223

   224

/**

   225

 * Initialize some AI-related stuff.

   226

 */

   227

void AI_Initialize()

   228

{

   229

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

   230

	AI_Uninitialize();

   231

   232

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

   233

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

   234

   235

	_ai.enabled = true;

   236

}

   237

   238

/**

   239

 * Deinitializer for AI-related stuff.

   240

 */

   241

void AI_Uninitialize()

   242

{

   243

	const Player* p;

   244

   245

	FOR_ALL_PLAYERS(p) {

   246

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

   247

	}

   248

}