1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../openttd.h"

     5

#include "../variables.h"

     6

#include "../command.h"

     7

#include "../network.h"

     8

#include "ai.h"

     9

#include "default/default.h"

    10

    11

/**

    12

 * Dequeues commands put in the queue via AI_PutCommandInQueue.

    13

 */

    14

static void AI_DequeueCommands(byte player)

    15

{

    16

	AICommand *com, *entry_com;

    17

    18

	entry_com = _ai_player[player].queue;

    19

    20

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

    21

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

    22

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

    23

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

    24

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

    25

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

    26

	_ai_player[player].queue = NULL;

    27

	_ai_player[player].queue_tail = NULL;

    28

    29

	/* Dequeue all commands */

    30

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

    31

		_current_player = player;

    32

    33

		/* Copy the DP back in place */

    34

		_cmd_text = com->text;

    35

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

    36

    37

		/* Free item */

    38

		entry_com = com->next;

    39

		if (com->text != NULL)

    40

			free(com->text);

    41

		free(com);

    42

	}

    43

}

    44

    45

/**

    46

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

    47

 *  will make infinite loops (AIScript).

    48

 */

    49

static void AI_PutCommandInQueue(byte player, uint tile, uint32 p1, uint32 p2, uint procc)

    50

{

    51

	AICommand *com;

    52

    53

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

    54

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

    55

		_ai_player[player].queue = malloc(sizeof(AICommand));

    56

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

    57

	} else {

    58

		/* Add an item at the end */

    59

		_ai_player[player].queue_tail->next = malloc(sizeof(AICommand));

    60

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

    61

	}

    62

    63

	/* This is our new item */

    64

	com = _ai_player[player].queue_tail;

    65

    66

	/* Assign the info */

    67

	com->tile  = tile;

    68

	com->p1    = p1;

    69

	com->p2    = p2;

    70

	com->procc = procc;

    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

 */

    84

int32 AI_DoCommand(uint tile, uint32 p1, uint32 p2, uint32 flags, uint procc)

    85

{

    86

	PlayerID old_lp;

    87

	int32 res = 0;

    88

	char *tmp_cmdtext = NULL;

    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 free _cmd_text in most cases, so let's backup the string, else we have a problem ;) */

    95

	if (_cmd_text != NULL)

    96

		tmp_cmdtext = strdup(_cmd_text);

    97

    98

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

   100

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

   101

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

   102

		if (tmp_cmdtext != NULL)

   103

			free(tmp_cmdtext);

   104

		return res;

   105

	}

   106

   107

	/* Recover _cmd_text */

   108

	if (tmp_cmdtext != NULL)

   109

		_cmd_text = tmp_cmdtext;

   110

   111

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

   112

	    over the network */

   113

	if (flags & DC_AUTO)                  procc |= CMD_AUTO;

   114

	if (flags & DC_NO_WATER)              procc |= CMD_NO_WATER;

   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, NULL);

   126

	else

   127

#endif

   128

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

   129

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

   130

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

   131

   132

	/* Set _local_player back */

   133

	_local_player = old_lp;

   134

   135

	/* Free the temp _cmd_text var */

   136

	if (tmp_cmdtext != NULL)

   137

		free(tmp_cmdtext);

   138

   139

	return res;

   140

}

   141

   142

/**

   143

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

   144

 */

   145

static void AI_RunTick(PlayerID player)

   146

{

   147

	extern void AiNewDoGameLoop(Player *p);

   148

   149

	Player *p = GetPlayer(player);

   150

	_current_player = player;

   151

   152

	if (_patches.ainew_active) {

   153

		AiNewDoGameLoop(p);

   154

	} else {

   155

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

   156

		_is_old_ai_player = true;

   157

		AiDoGameLoop(p);

   158

		_is_old_ai_player = false;

   159

	}

   160

}

   161

   162

   163

/**

   164

 * The gameloop for AIs.

   165

 *  Handles one tick for all the AIs.

   166

 */

   167

void AI_RunGameLoop(void)

   168

{

   169

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

   170

	if (!_ai.enabled) return;

   171

   172

	/* Don't do anything if we are a network-client

   173

	 *  (too bad when a client joins, he thinks the AIs are real, so it wants to control

   174

	 *   them.. this avoids that, while loading a network game in singleplayer, does make

   175

	 *   the AIs to continue ;))

   176

	 */

   177

	if (_networking && !_network_server && !_ai.network_client)

   178

		return;

   179

   180

	/* New tick */

   181

	_ai.tick++;

   182

   183

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

   184

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

   185

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

   186

		return;

   187

   188

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

   189

	if (_ai.network_client && _ai_player[_ai.network_playas].active) {

   190

		/* Run the script */

   191

		AI_DequeueCommands(_ai.network_playas);

   192

		AI_RunTick(_ai.network_playas);

   193

	} else if (!_networking || _network_server) {

   194

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

   195

		Player *p;

   196

   197

		FOR_ALL_PLAYERS(p) {

   198

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

   199

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

   200

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

   201

   202

				/* Run the script */

   203

				AI_DequeueCommands(p->index);

   204

				AI_RunTick(p->index);

   205

			}

   206

		}

   207

	}

   208

   209

	_current_player = OWNER_NONE;

   210

}

   211

   212

/**

   213

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

   214

 */

   215

void AI_StartNewAI(PlayerID player)

   216

{

   217

	assert(player < MAX_PLAYERS);

   218

   219

	/* Called if a new AI is booted */

   220

	_ai_player[player].active = true;

   221

}

   222

   223

/**

   224

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

   225

 */

   226

void AI_PlayerDied(PlayerID player)

   227

{

   228

	if (_ai.network_client && _ai.network_playas == player)

   229

		_ai.network_playas = OWNER_SPECTATOR;

   230

   231

	/* Called if this AI died */

   232

	_ai_player[player].active = false;

   233

}

   234

   235

/**

   236

 * Initialize some AI-related stuff.

   237

 */

   238

void AI_Initialize(void)

   239

{

   240

	bool ai_network_client = _ai.network_client;

   241

   242

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

   243

	AI_Uninitialize();

   244

   245

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

   246

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

   247

   248

	_ai.network_client = ai_network_client;

   249

	_ai.network_playas = OWNER_SPECTATOR;

   250

	_ai.enabled = true;

   251

}

   252

   253

/**

   254

 * Deinitializer for AI-related stuff.

   255

 */

   256

void AI_Uninitialize(void)

   257

{

   258

	Player* p;

   259

   260

	FOR_ALL_PLAYERS(p) {

   261

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

   262

	}

   263

}