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

     9

#include "ai.h"

    10

#include "default/default.h"

    11

    12

/* Here we define the events */

    13

#define DEF_EVENTS

    14

#include "ai_event.h"

    15

#undef DEF_EVENTS

    16

    17

/**

    18

 * Dequeues commands put in the queue via AI_PutCommandInQueue.

    19

 */

    20

void AI_DequeueCommands(byte player)

    21

{

    22

	AICommand *com, *entry_com;

    23

    24

	entry_com = _ai_player[player].queue;

    25

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

	_ai_player[player].queue = NULL;

    33

	_ai_player[player].queue_tail = NULL;

    34

    35

	/* Dequeue all commands */

    36

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

    37

		_current_player = player;

    38

    39

		/* Copy the DP back in place */

    40

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

    41

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

    42

    43

		/* Free item */

    44

		entry_com = com->next;

    45

		free(com);

    46

	}

    47

}

    48

    49

/**

    50

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

    51

 *  will make infinite loops (AIScript).

    52

 */

    53

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

    54

{

    55

	AICommand *com;

    56

    57

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

    58

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

    59

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

    60

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

    61

	} else {

    62

		/* Add an item at the end */

    63

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

    64

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

    65

	}

    66

    67

	/* This is our new item */

    68

	com = _ai_player[player].queue_tail;

    69

    70

	/* Assign the info */

    71

	com->tile  = tile;

    72

	com->p1    = p1;

    73

	com->p2    = p2;

    74

	com->procc = procc;

    75

	com->next  = NULL;

    76

    77

	/* Copy the decode_parameters */

    78

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

    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

    89

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

    90

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

    91

	 */

    92

    93

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

    94

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

    95

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

    96

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

    97

		return res;

    98

    99

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

   100

	    over the network */

   101

	if (flags & DC_AUTO)                  procc |= CMD_AUTO;

   102

	if (flags & DC_NO_WATER)              procc |= CMD_NO_WATER;

   103

   104

	/* NetworkSend_Command needs _local_player to be set correctly, so

   105

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

   106

	old_lp = _local_player;

   107

	_local_player = _current_player;

   108

   109

	/* Send the command */

   110

	if (_networking)

   111

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

   112

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

   113

	else

   114

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

   115

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

   116

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

   117

   118

	/* Set _local_player back */

   119

	_local_player = old_lp;

   120

   121

	return res;

   122

}

   123

   124

/**

   125

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

   126

 */

   127

static void AI_RunTick(PlayerID player)

   128

{

   129

	_current_player = player;

   130

   131

#ifdef GPMI

   132

	if (_ai.gpmi) {

   133

		gpmi_call_RunTick(_ai_player[player].module, _frame_counter);

   134

		return;

   135

	}

   136

#endif /* GPMI */

   137

   138

	{

   139

		extern void AiNewDoGameLoop(Player *p);

   140

   141

		Player *p = GetPlayer(player);

   142

   143

		if (_patches.ainew_active) {

   144

			AiNewDoGameLoop(p);

   145

		} else {

   146

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

   147

			_is_old_ai_player = true;

   148

			AiDoGameLoop(p);

   149

			_is_old_ai_player = false;

   150

		}

   151

	}

   152

}

   153

   154

   155

/**

   156

 * The gameloop for AIs.

   157

 *  Handles one tick for all the AIs.

   158

 */

   159

void AI_RunGameLoop(void)

   160

{

   161

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

   162

	if (!_ai.enabled) return;

   163

   164

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

   165

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

   166

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

   167

	 *   the AIs to continue ;))

   168

	 */

   169

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

   170

		return;

   171

   172

	/* New tick */

   173

	_ai.tick++;

   174

   175

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

   176

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

   177

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

   178

		return;

   179

   180

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

   181

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

   182

		/* Run the script */

   183

		AI_DequeueCommands(_ai.network_playas);

   184

		AI_RunTick(_ai.network_playas);

   185

	} else if (!_networking || _network_server) {

   186

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

   187

		Player *p;

   188

   189

		FOR_ALL_PLAYERS(p) {

   190

			if (p->is_active && p->is_ai && _ai_player[p->index].active) {

   191

				/* Run the script */

   192

				AI_DequeueCommands(p->index);

   193

				AI_RunTick(p->index);

   194

			}

   195

		}

   196

	}

   197

   198

	_current_player = OWNER_NONE;

   199

}

   200

   201

/**

   202

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

   203

 */

   204

void AI_StartNewAI(PlayerID player)

   205

{

   206

#ifdef GPMI

   207

	char library[80];

   208

	char params[80];

   209

   210

	/* XXX -- Todo, make a nice assign for library and params from a nice GUI :) */

   211

	snprintf(library, sizeof(library), "php");

   212

	snprintf(params,  sizeof(params),  "daeb");

   213

   214

	_ai_player[player].module = gpmi_mod_load(library, params);

   215

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

   216

		DEBUG(ai, 0)("[AI] Failed to load AI, aborting..");

   217

		return;

   218

	}

   219

#endif /* GPMI */

   220

   221

	/* Called if a new AI is booted */

   222

	_ai_player[player].active = true;

   223

}

   224

   225

/**

   226

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

   227

 */

   228

void AI_PlayerDied(PlayerID player)

   229

{

   230

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

   231

		_ai.network_playas = OWNER_SPECTATOR;

   232

   233

	/* Called if this AI died */

   234

	_ai_player[player].active = false;

   235

   236

#ifdef GPMI

   237

	gpmi_mod_unload(_ai_player[player].module);

   238

#endif /* GPMI */

   239

}

   240

   241

/**

   242

 * Initialize some AI-related stuff.

   243

 */

   244

void AI_Initialize(void)

   245

{

   246

	bool tmp_ai_network_client = _ai.network_client;

   247

	bool tmp_ai_gpmi = _ai.gpmi;

   248

   249

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

   250

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

   251

   252

	_ai.network_client = tmp_ai_network_client;

   253

	_ai.network_playas = OWNER_SPECTATOR;

   254

	_ai.enabled = true;

   255

	_ai.gpmi = tmp_ai_gpmi;

   256

}

   257

   258

/**

   259

 * Deinitializer for AI-related stuff.

   260

 */

   261

void AI_Uninitialize(void)

   262

{

   263

	Player* p;

   264

   265

	FOR_ALL_PLAYERS(p) {

   266

		if (p->is_active && p->is_ai && _ai_player[p->index].active) AI_PlayerDied(p->index);

   267

	}

   268

}