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

#include "../string.h"

    12

    13

/* Here we define the events */

    14

#define DEF_EVENTS

    15

#include "ai_event.h"

    16

#undef DEF_EVENTS

    17

    18

/* Here we keep track of all commands that are called via AI_DoCommandChecked,

    19

 *  in special we save the unique_id here. Now this id is given back

    20

 *  when the command fails or succeeds and is detected as added in this storage. */

    21

static AICommand *command_uid[MAX_PLAYERS];

    22

static AICommand *command_uid_tail[MAX_PLAYERS];

    23

static uint uids[MAX_PLAYERS];

    24

    25

/**

    26

 * Dequeues commands put in the queue via AI_PutCommandInQueue.

    27

 */

    28

void AI_DequeueCommands(byte player)

    29

{

    30

	AICommand *com, *entry_com;

    31

    32

	entry_com = _ai_player[player].queue;

    33

    34

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

    35

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

    36

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

    37

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

    38

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

    39

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

    40

	_ai_player[player].queue = NULL;

    41

	_ai_player[player].queue_tail = NULL;

    42

    43

	/* Dequeue all commands */

    44

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

    45

		_current_player = player;

    46

    47

		/* Copy the DP back in place */

    48

		_cmd_text = com->text;

    49

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

    50

    51

		/* Free item */

    52

		entry_com = com->next;

    53

		if (com->text != NULL)

    54

			free(com->text);

    55

		free(com);

    56

	}

    57

}

    58

    59

/**

    60

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

    61

 *  will make infinite loops (AIScript).

    62

 */

    63

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

    64

{

    65

	AICommand *com;

    66

    67

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

    68

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

    69

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

    70

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

    71

	} else {

    72

		/* Add an item at the end */

    73

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

    74

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

    75

	}

    76

    77

	/* This is our new item */

    78

	com = _ai_player[player].queue_tail;

    79

    80

	/* Assign the info */

    81

	com->tile  = tile;

    82

	com->p1    = p1;

    83

	com->p2    = p2;

    84

	com->procc = procc;

    85

	com->next  = NULL;

    86

	com->text  = NULL;

    87

    88

	/* Copy the cmd_text, if needed */

    89

	if (_cmd_text != NULL) {

    90

		com->text = strdup(_cmd_text);

    91

		_cmd_text = NULL;

    92

	}

    93

}

    94

    95

/**

    96

 * Executes a raw DoCommand for the AI.

    97

 */

    98

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

    99

{

   100

	PlayerID old_lp;

   101

	int32 res = 0;

   103

   104

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

   105

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

   106

	 */

   107

   108

	/* The test already free _cmd_text in most cases, so let's backup the string, else we have a problem ;) */

   109

	if (_cmd_text != NULL)

   111

   112

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

   113

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

   114

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

   115

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

   118

		return res;

   119

	}

   120

   121

	/* Recover _cmd_text */

   124

   125

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

   126

	    over the network */

   127

	if (flags & DC_AUTO)                  procc |= CMD_AUTO;

   128

	if (flags & DC_NO_WATER)              procc |= CMD_NO_WATER;

   129

   130

	/* NetworkSend_Command needs _local_player to be set correctly, so

   131

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

   132

	old_lp = _local_player;

   133

	_local_player = _current_player;

   134

   135

#ifdef ENABLE_NETWORK

   136

	/* Send the command */

   137

	if (_networking)

   138

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

   139

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

   140

	else

   141

#endif

   142

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

   143

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

   144

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

   145

   146

	/* Set _local_player back */

   147

	_local_player = old_lp;

   148

   149

	/* Free the temp _cmd_text var */

   152

   153

	return res;

   154

}

   155

   156

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

   157

{

   158

	AICommand *new;

   159

	uint unique_id = uids[_current_player];

   160

	int32 res;

   161

   162

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

   163

	if (CmdFailed(res))

   164

		return CMD_ERROR;

   165

	if (!(flags & DC_EXEC))

   166

		return res;

   167

   168

	uids[_current_player]++;

   169

   170

	/* Save the command and his things, together with the unique_id */

   171

	new = malloc(sizeof(AICommand));

   172

	new->tile  = tile;

   173

	new->p1    = p1;

   174

	new->p2    = p2;

   175

	new->procc = procc;

   176

	new->next  = NULL;

   177

	new->uid   = unique_id;

   178

   179

	/* Add it to the back of the list */

   180

	if (command_uid_tail[_current_player] == NULL)

   181

		command_uid_tail[_current_player] = new;

   182

	else {

   183

		command_uid_tail[_current_player]->next = new;

   184

		command_uid_tail[_current_player] = new;

   185

	}

   186

   187

	if (command_uid[_current_player] == NULL)

   188

		command_uid[_current_player] = new;

   189

   190

	AI_DoCommand(tile, p1, p2, flags, procc);

   191

	return unique_id;

   192

}

   193

   194

/**

   195

 * A command is executed for real, and is giving us his result (failed yes/no). Inform the AI with it via

   196

 *  an event.Z

   197

 */

   198

void AI_CommandResult(uint32 cmd, uint32 p1, uint32 p2, TileIndex tile, bool succeeded)

   199

{

   200

	AICommand *command = command_uid[_current_player];

   201

   202

	if (command == NULL)

   203

		return;

   204

   205

	if (command->procc != (cmd & 0xFF) || command->p1 != p1 || command->p2 != p2 || command->tile != tile) {

   206

		/* If we come here, we see a command that isn't at top in our list. This is okay, if the command isn't

   207

		 *  anywhere else in our list, else we have a big problem.. so check for that. If it isn't in our list,

   208

		 *  it is okay, else, drop the game.

   209

		 * Why do we have a big problem in the case it is in our list? Simply, we have a command sooner in

   210

		 *  our list that wasn't triggered to be failed or succeeded, so it is sitting there without an

   211

		 *  event, so the script will never know if it succeeded yes/no, so it can hang.. this is VERY bad

   212

		 *  and should never ever happen. */

   213

		while (command != NULL && (command->procc != (cmd & 0xFF) || command->p1 != p1 || command->p2 != p2 || command->tile != tile)) {

   214

			command = command->next;

   215

		}

   216

		assert(command == NULL);

   217

		return;

   218

	}

   219

   220

	command_uid[_current_player] = command_uid[_current_player]->next;

   221

	if (command_uid[_current_player] == NULL)

   222

		command_uid_tail[_current_player] = NULL;

   223

   224

	ai_event(_current_player, succeeded ? ottd_Event_CommandSucceeded : ottd_Event_CommandFailed, tile, command->uid);

   225

	free(command);

   226

}

   227

   228

/**

   229

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

   230

 */

   231

static void AI_RunTick(PlayerID player)

   232

{

   233

	_current_player = player;

   234

   235

#ifdef GPMI

   236

	if (_ai.gpmi) {

   237

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

   238

		return;

   239

	}

   240

#endif /* GPMI */

   241

   242

	{

   243

		extern void AiNewDoGameLoop(Player *p);

   244

   245

		Player *p = GetPlayer(player);

   246

   247

		if (_patches.ainew_active) {

   248

			AiNewDoGameLoop(p);

   249

		} else {

   250

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

   251

			_is_old_ai_player = true;

   252

			AiDoGameLoop(p);

   253

			_is_old_ai_player = false;

   254

		}

   255

	}

   256

}

   257

   258

   259

/**

   260

 * The gameloop for AIs.

   261

 *  Handles one tick for all the AIs.

   262

 */

   263

void AI_RunGameLoop(void)

   264

{

   265

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

   266

	if (!_ai.enabled) return;

   267

   268

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

   269

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

   270

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

   271

	 *   the AIs to continue ;))

   272

	 */

   273

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

   274

		return;

   275

   276

	/* New tick */

   277

	_ai.tick++;

   278

   279

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

   280

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

   281

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

   282

		return;

   283

   284

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

   285

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

   286

		/* Run the script */

   287

		AI_DequeueCommands(_ai.network_playas);

   288

		AI_RunTick(_ai.network_playas);

   289

	} else if (!_networking || _network_server) {

   290

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

   291

		Player *p;

   292

   293

		FOR_ALL_PLAYERS(p) {

   294

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

   295

				/* Run the script */

   296

				AI_DequeueCommands(p->index);

   297

				AI_RunTick(p->index);

   298

			}

   299

		}

   300

	}

   301

   302

	_current_player = OWNER_NONE;

   303

}

   304

   305

#ifdef GPMI

   306

   307

void AI_ShutdownAIControl(bool with_error)

   308

{

   309

	if (_ai.gpmi_mod != NULL)

   310

		gpmi_mod_unload(_ai.gpmi_mod);

   311

	if (_ai.gpmi_pkg != NULL)

   312

		gpmi_pkg_unload(_ai.gpmi_pkg);

   313

   314

	if (with_error) {

   315

		DEBUG(ai, 0)("[AI] Failed to load AI Control, switching back to built-in AIs..");

   316

		_ai.gpmi = false;

   317

	}

   318

}

   319

   320

void (*ottd_GetNextAIData)(char **library, char **param);

   321

void (*ottd_SetAIParam)(char *param);

   322

   323

void AI_LoadAIControl(void)

   324

{

   325

	/* Load module */

   326

	_ai.gpmi_mod = gpmi_mod_load("ottd_ai_control_mod", NULL);

   327

	if (_ai.gpmi_mod == NULL) {

   328

		AI_ShutdownAIControl(true);

   329

		return;

   330

	}

   331

   332

	/* Load package */

   333

	if (gpmi_pkg_load("ottd_ai_control_pkg", 0, NULL, NULL, &_ai.gpmi_pkg)) {

   334

		AI_ShutdownAIControl(true);

   335

		return;

   336

	}

   337

   338

	/* Now link all the functions */

   339

	{

   340

		ottd_GetNextAIData = gpmi_pkg_resolve(_ai.gpmi_pkg, "ottd_GetNextAIData");

   341

		ottd_SetAIParam = gpmi_pkg_resolve(_ai.gpmi_pkg, "ottd_SetAIParam");

   342

   343

		if (ottd_GetNextAIData == NULL || ottd_SetAIParam == NULL)

   344

			AI_ShutdownAIControl(true);

   345

	}

   346

   347

	ottd_SetAIParam(_ai.gpmi_param);

   348

}

   349

   350

/**

   351

 * Dump an entry of the GPMI error stack (callback routine). This helps the user to trace errors back to their roots.

   352

 */

   353

void AI_PrintErrorStack(gpmi_err_stack_t *entry, char *string)

   354

{

   355

	DEBUG(ai, 0)("%s", string);

   356

}

   357

   358

#endif /* GPMI */

   359

   360

/**

   361

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

   362

 */

   363

void AI_StartNewAI(PlayerID player)

   364

{

   365

	assert(player < MAX_PLAYERS);

   366

   367

#ifdef GPMI

   368

	/* Keep this in a different IF, because the function can turn _ai.gpmi off!! */

   369

	if (_ai.gpmi && _ai.gpmi_mod == NULL)

   370

		AI_LoadAIControl();

   371

   372

	if (_ai.gpmi) {

   373

		char *library = NULL;

   374

		char *params = NULL;

   375

   376

		ottd_GetNextAIData(&library, &params);

   377

		gpmi_error_stack_enable = 1;

   378

   379

		if (library != NULL) {

   380

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

   381

			free(library);

   382

		}

   383

		if (params != NULL)

   384

			free(params);

   385

   386

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

   387

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

   388

			gpmi_err_stack_process_str(AI_PrintErrorStack);

   389

			return;

   390

		}

   391

		gpmi_error_stack_enable = 0;

   392

   393

	}

   394

#endif /* GPMI */

   395

   396

	/* Called if a new AI is booted */

   397

	_ai_player[player].active = true;

   398

}

   399

   400

/**

   401

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

   402

 */

   403

void AI_PlayerDied(PlayerID player)

   404

{

   405

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

   406

		_ai.network_playas = OWNER_SPECTATOR;

   407

   408

	/* Called if this AI died */

   409

	_ai_player[player].active = false;

   410

   411

	if (command_uid[player] != NULL) {

   412

		while (command_uid[player] != NULL) {

   413

			AICommand *command = command_uid[player];

   414

			command_uid[player] = command->next;

   415

			free(command);

   416

		}

   417

   418

		command_uid[player] = NULL;

   419

		command_uid_tail[player] = NULL;

   420

	}

   421

   422

#ifdef GPMI

   423

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

   424

		gpmi_mod_unload(_ai_player[player].module);

   425

#endif /* GPMI */

   426

}

   427

   428

/**

   429

 * Initialize some AI-related stuff.

   430

 */

   431

void AI_Initialize(void)

   432

{

   433

	bool tmp_ai_network_client = _ai.network_client;

   434

	bool tmp_ai_gpmi = _ai.gpmi;

   435

#ifdef GPMI

   436

	char *tmp_ai_gpmi_param = strdup(_ai.gpmi_param);

   437

#endif /* GPMI */

   438

   439

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

   440

	AI_Uninitialize();

   441

   442

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

   443

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

   444

	memset(uids, 0, sizeof(uids));

   445

	memset(command_uid, 0, sizeof(command_uid));

   446

	memset(command_uid_tail, 0, sizeof(command_uid_tail));

   447

   448

	_ai.network_client = tmp_ai_network_client;

   449

	_ai.network_playas = OWNER_SPECTATOR;

   450

	_ai.enabled = true;

   451

	_ai.gpmi = tmp_ai_gpmi;

   452

#ifdef GPMI

   453

	ttd_strlcpy(_ai.gpmi_param, tmp_ai_gpmi_param, sizeof(_ai.gpmi_param));

   454

	free(tmp_ai_gpmi_param);

   455

#endif /* GPMI */

   456

}

   457

   458

/**

   459

 * Deinitializer for AI-related stuff.

   460

 */

   461

void AI_Uninitialize(void)

   462

{

   463

	Player* p;

   464

   465

	FOR_ALL_PLAYERS(p) {

   466

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

   467

	}

   468

   469

#ifdef GPMI

   470

	AI_ShutdownAIControl(false);

   471

#endif /* GPMI */

   472

}