1

/* $Id$ */

     2

     3

/** @file ai.cpp Handles the communication between the AI layer and the OpenTTD core */

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h"

     7

#include "../variables.h"

     8

#include "../command_func.h"

     9

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

    10

#include "../core/alloc_func.hpp"

    11

#include "../settings_type.h"

    12

#include "../player_base.h"

    13

#include "../player_func.h"

    14

#include "../debug.h"

    15

    16

#ifndef NO_THREADS

    17

#include <squirrel.h>

    18

#include "../squirrel.hpp"

    19

#include "../squirrel_helper.hpp"

    20

#include "../squirrel_class.hpp"

    21

#include "../squirrel_std.hpp"

    22

#include "api/ai_controller.hpp"

    23

#include "ai_squirrel.hpp"

    24

#include "ai_info.hpp"

    25

#include "ai.h"

    26

#include "ai_threads.h"

    27

#include "api/ai_base.hpp"

    28

#include "../signal_func.h"

    29

#include "../window_func.h"

    30

    31

static AIController *_ai_player[MAX_PLAYERS];

    32

static AIInfo *_ai_info[MAX_PLAYERS];

    33

static AISquirrel *_ai_squirrel = NULL;

    34

static uint _ai_frame_counter;

    35

static bool _ai_enabled;

    36

static char *_forced_ai_name = NULL;

    37

    38

/**

    39

 * The gameloop for AIs.

    40

 *  Handles one tick for all the AIs.

    41

 */

    42

void AI_RunGameLoop()

    43

{

    44

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

    45

	if (!_ai_enabled) return;

    46

    47

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

    48

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

    49

    50

	/* New tick */

    51

	_ai_frame_counter++;

    52

    53

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

    54

	assert(_settings_game.difficulty.competitor_speed <= 4);

    55

	if ((_ai_frame_counter & ((1 << (4 - _settings_game.difficulty.competitor_speed)) - 1)) != 0) return;

    56

    57

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

    58

	if (!_networking || _network_server) {

    59

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

    60

		const Player *p;

    61

    62

		FOR_ALL_PLAYERS(p) {

    63

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

    64

				/* Run the script */

    65

				if (_ai_player[p->index] == NULL) continue;

    66

				_current_player = p->index;

    67

				AI_RunTick(p->index);

    68

			}

    69

		}

    70

	}

    71

    72

	_current_player = OWNER_NONE;

    73

}

    74

    75

void AI_Event(PlayerID player, AIEvent *event)

    76

{

    77

	if (player >= MAX_PLAYERS || !GetPlayer(player)->is_active || !GetPlayer(player)->is_ai) return;

    78

	DEBUG(ai, 5, "Event (%d) for player %d\n", event->GetEventType(), player);

    79

    80

	PlayerID old_player = _current_player;

    81

	_current_player = player;

    82

	AIEventController::InsertEvent(event);

    83

	_current_player = old_player;

    84

}

    85

    86

/**

    87

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

    88

 * @return True if the AI is started.

    89

 */

    90

bool AI_StartNewAI(PlayerID player)

    91

{

    92

	assert(IsValidPlayer(player));

    93

	if (!_ai_enabled) return false;

    94

	if (_networking && !_network_server) return false;

    95

    96

	AIInfo *info;

    97

	if (_forced_ai_name == NULL) {

    98

		info = _ai_squirrel->SelectRandomAI();

    99

	} else {

   100

		info = _ai_squirrel->SelectAI(_forced_ai_name);

   101

	}

   102

	if (info == NULL) {

   103

		if (_forced_ai_name == NULL) {

   104

			DEBUG(ai, 0, "Couldn't find a suitable AI to start for company '%d'", player);

   105

		} else {

   106

			DEBUG(ai, 0, "The AI named \"%s\" is unknown or not suitable", _forced_ai_name);

   107

		}

   108

		return false;

   109

	}

   110

   111

	_current_player = player;

   112

	_ai_info[player] = info;

   113

	AIObject::ResetInternalPlayerData();

   114

	_ai_player[player] = info->CreateInstance();

   115

	AI_StartPlayer(player, _ai_player[player]);

   116

	InvalidateWindowData(WC_AI_DEBUG, 0, -1);

   117

	return true;

   118

}

   119

   120

/**

   121

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

   122

 */

   123

void AI_PlayerDied(PlayerID player)

   124

{

   125

	if (!_ai_enabled) return;

   126

   127

	_current_player = player;

   128

	AI_StopPlayer(player);

   129

	/* Called if this AI died */

   130

	delete _ai_player[player];

   131

	_ai_player[player] = NULL;

   132

	_ai_info[player] = NULL;

   133

	InvalidateWindowData(WC_AI_DEBUG, 0, -1);

   134

}

   135

   136

/**

   137

 * Initialize some AI-related stuff.

   138

 */

   139

void AI_Initialize()

   140

{

   141

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

   142

	AI_Uninitialize();

   143

   144

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

   145

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

   146

	_ai_frame_counter = 0;

   147

	_ai_enabled = true;

   148

   149

	/* Create the Squirrel collector, which scans for all AIs available */

   150

	assert(_ai_squirrel == NULL);

   151

	_ai_squirrel = new AISquirrel();

   152

}

   153

   154

/**

   155

 * Forces the given AI to be used for all players.

   156

 * Pass NULL to use a random AI.

   157

 * @param forced_ai the AI to force.

   158

 */

   159

void AI_ForceAI(const char *forced_ai)

   160

{

   161

	free(_forced_ai_name);

   162

	_forced_ai_name = (forced_ai == NULL) ? NULL : strdup(forced_ai);

   163

}

   164

   165

char *AI_GetConsoleList(char *p, const char *last)

   166

{

   167

	return _ai_squirrel->GetAIConsoleList(p, last);

   168

}

   169

   170

AIInfo *AI_GetPlayerInfo(PlayerID player)

   171

{

   172

	return _ai_info[player];

   173

}

   174

   175

/**

   176

 * Kill all AIs.

   177

 */

   178

void AI_KillAll()

   179

{

   180

	const Player* p;

   181

   182

	FOR_ALL_PLAYERS(p) {

   183

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

   184

	}

   185

}

   186

   187

/**

   188

 * Deinitializer for AI-related stuff.

   189

 */

   190

void AI_Uninitialize()

   191

{

   192

	AI_KillAll();

   193

	delete _ai_squirrel;

   194

	_ai_squirrel = NULL;

   195

}

   196

   197

/**

   198

 * Is it allowed to start a new AI.

   199

 * This function checks some boundries to see if we should launch a new AI.

   200

 * @return True if we can start a new AI.

   201

 */

   202

bool AI_AllowNewAI()

   203

{

   204

	/* If disabled, no AI */

   205

	if (!_ai_enabled) return false;

   206

   207

	/* If in network, but no server, no AI */

   208

	if (_networking && !_network_server) return false;

   209

   210

	/* If in network, and server, possible AI */

   211

	if (_networking && _network_server) {

   212

		/* Do we want AIs in multiplayer? */

   213

		if (!_settings_game.ai.ai_in_multiplayer) return false;

   214

	}

   215

   216

	return true;

   217

}

   218

   219

bool AI_ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm)

   220

{

   222

}

   223

   224

void AI_Rescan()

   225

{

   226

	_ai_squirrel->RescanAIDir();

   227

}

   228

   229

#else /* NO_THREADS */

   230

/* Stub functions for when we do not have threads. */

   231

void AI_StartNewAI(PlayerID player) { DEBUG(ai, 0, "Threading is disabled and therefor the AI too."); }

   232

void AI_PlayerDied(PlayerID player) {}

   233

void AI_RunGameLoop() {}

   234

void AI_Event(PlayerID player, AIEvent *event) {}

   235

void AI_Initialize() {}

   236

void AI_Uninitialize() {}

   237

bool AI_AllowNewAI() { return false; }

   238

void AI_ForceAI(const char *forced_ai) {}

   239

char *AI_GetConsoleList(char *p, const char *last) { return p; }

   240

AIInfo *AI_GetPlayerInfo(PlayerID player) { return NULL; }

   241

bool AI_ImportLibrary(const char *library, const char *class_name, int version, HSQUIRRELVM vm) { return false; }

   242

void CcAI(bool success, TileIndex tile, uint32 p1, uint32 p2) {}

   243

void AI_Rescan() {}

   244

#endif /* NO_THREADS */