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

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

		memcpy(_decode_parameters, com->dp, sizeof(com->dp));

    35

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

    36

    37

		/* Free item */

    38

		entry_com = com->next;

    39

		free(com);

    40

	}

    41

}

    42

    43

/**

    44

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

    45

 *  will make infinite loops (AIScript).

    46

 */

    47

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

    48

{

    49

	AICommand *com;

    50

    51

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

    52

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

    53

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

    54

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

    55

	} else {

    56

		/* Add an item at the end */

    57

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

    58

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

    59

	}

    60

    61

	/* This is our new item */

    62

	com = _ai_player[player].queue_tail;

    63

    64

	/* Assign the info */

    65

	com->tile  = tile;

    66

	com->p1    = p1;

    67

	com->p2    = p2;

    68

	com->procc = procc;

    69

	com->next  = NULL;

    70

    71

	/* Copy the decode_parameters */

    72

	memcpy(com->dp, _decode_parameters, sizeof(com->dp));

    73

}

    74

    75

/**

    76

 * Executes a raw DoCommand for the AI.

    77

 */

    78

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

    79

{

    81

	int32 res = 0;

    82

    83

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

    84

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

    85

	 */

    86

    87

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

    88

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

    89

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

    90

	if ((res & CMD_ERROR) || !(flags & DC_EXEC) || (flags & DC_QUERY_COST))

    91

		return res;

    92

    93

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

    94

	    over the network */

    95

	if (flags & DC_AUTO)                  procc |= CMD_AUTO;

    96

	if (flags & DC_NO_WATER)              procc |= CMD_NO_WATER;

    97

    98

	/* NetworkSend_Command needs _local_player to be set correctly, so

    99

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

   100

	old_lp = _local_player;

   101

	_local_player = _current_player;

   102

   103

	/* Send the command */

   104

	if (_networking)

   105

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

   106

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

   107

	else

   108

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

   109

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

   110

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

   111

   112

	/* Set _local_player back */

   113

	_local_player = old_lp;

   114

   115

	return res;

   116

}

   117

   118

/**

   119

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

   120

 */

   122

{

   123

	extern void AiNewDoGameLoop(Player *p);

   124

   125

	Player *p = GetPlayer(player);

   126

	_current_player = player;

   127

   128

	if (_patches.ainew_active)

   129

		AiNewDoGameLoop(p);

   130

	else {

   131

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

   132

		_is_old_ai_player = true;

   133

		AiDoGameLoop(p);

   134

		_is_old_ai_player = false;

   135

	}

   136

}

   137

   138

   139

/**

   140

 * The gameloop for AIs.

   141

 *  Handles one tick for all the AIs.

   142

 */

   143

void AI_RunGameLoop(void)

   144

{

   145

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

   146

	if (!_ai.enabled)

   147

		return;

   148

   149

	/* New tick */

   150

	_ai.tick++;

   151

   152

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

   153

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

   154

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

   155

		return;

   156

   157

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

   158

	if (_ai.network_client) {

   159

		/* Run the script */

   160

		AI_DequeueCommands(_ai.network_player);

   161

		AI_RunTick(_ai.network_player);

   162

	} else if (!_networking || _network_server) {

   163

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

   164

		Player *p;

   165

   166

		FOR_ALL_PLAYERS(p) {

   167

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

   168

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

   169

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

   170

   171

				/* Run the script */

   172

				AI_DequeueCommands(p->index);

   173

				AI_RunTick(p->index);

   174

			}

   175

		}

   176

	}

   177

   178

	_current_player = OWNER_NONE;

   179

}

   180

   181

/**

   182

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

   183

 */

   185

{

   186

	/* Called if a new AI is booted */

   187

	_ai_player[player].active = true;

   188

}

   189

   190

/**

   191

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

   192

 */

   194

{

   195

	/* Called if this AI died */

   196

	_ai_player[player].active = false;

   197

}

   198

   199

/**

   200

 * Initialize some AI-related stuff.

   201

 */

   202

void AI_Initialize(void)

   203

{

   204

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

   205

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

   206

   207

	_ai.enabled = true;

   208

}

   209

   210

/**

   211

 * Deinitializer for AI-related stuff.

   212

 */

   213

void AI_Uninitialize(void)

   214

{

   215

	Player *p;

   216

   217

	FOR_ALL_PLAYERS(p) {

   218

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

   219

			AI_PlayerDied(p->index);

   220

		}

   221

	}

   222

}