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

    30

static AIController *_ai_player[MAX_PLAYERS];

    31

static AIInfo *_ai_info[MAX_PLAYERS];

    32

static AISquirrel *_ai_squirrel = NULL;

    33

static uint _ai_frame_counter;

    34

static bool _ai_enabled;

    35

static char *_forced_ai_name = NULL;

    36

    37

/**

    38

 * The gameloop for AIs.

    39

 *  Handles one tick for all the AIs.

    40

 */

    41

void AI_RunGameLoop()

    42

{

    43

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

    44

	if (!_ai_enabled) return;

    45

    46

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

    47

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

    48

    49

	/* New tick */

    50

	_ai_frame_counter++;

    51

    52

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

    53

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

    54

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

    55

    56

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

    57

	if (!_networking || _network_server) {

    58

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

    59

		const Player *p;

    60

    61

		FOR_ALL_PLAYERS(p) {

    62

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

    63

				/* Run the script */

    64

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

    65

				_current_player = p->index;

    66

				AI_RunTick(p->index);

    67

			}

    68

		}

    69

	}

    70

    71

	_current_player = OWNER_NONE;

    72

}

    73

    74

void AI_Event(PlayerID player, AIEvent *event)

    75

{

    76

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

    77

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

    78

    79

	PlayerID old_player = _current_player;

    80

	_current_player = player;

    81

	AIEventController::InsertEvent(event);

    82

	_current_player = old_player;

    83

}

    84

    85

/**

    86

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

    87

 */

    88

void AI_StartNewAI(PlayerID player)

    89

{

    90

	assert(IsValidPlayer(player));

    91

	if (!_ai_enabled) return;

    92

	if (_networking && !_network_server) return;

    93

    94

	AIInfo *info;

    95

	if (_forced_ai_name == NULL) {

    96

		info = _ai_squirrel->SelectRandomAI();

    97

	} else {

    98

		info = _ai_squirrel->SelectAI(_forced_ai_name);

    99

	}

   100

	if (info == NULL) {

   101

		if (_forced_ai_name == NULL) {

   102

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

   103

		} else {

   104

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

   105

		}

   106

		/* XXX -- We have no clean way to handle this yet! */

   107

		return;

   108

	}

   109

   110

	_current_player = player;

   111

	_ai_info[player] = info;

   112

	AIObject::ResetInternalPlayerData();

   113

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

   114

	AI_StartPlayer(player, _ai_player[player]);

   115

}

   116

   117

/**

   118

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

   119

 */

   120

void AI_PlayerDied(PlayerID player)

   121

{

   122

	if (!_ai_enabled) return;

   123

   124

	_current_player = player;

   125

	AI_StopPlayer(player);

   126

	/* Called if this AI died */

   127

	delete _ai_player[player];

   128

	_ai_player[player] = NULL;

   129

	_ai_info[player] = NULL;

   130

}

   131

   132

/**

   133

 * Initialize some AI-related stuff.

   134

 */

   135

void AI_Initialize()

   136

{

   137

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

   138

	AI_Uninitialize();

   139

   140

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

   141

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

   142

	_ai_frame_counter = 0;

   143

	_ai_enabled = true;

   144

   145

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

   146

	assert(_ai_squirrel == NULL);

   147

	_ai_squirrel = new AISquirrel();

   148

}

   149

   150

/**

   151

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

   152

 * Pass NULL to use a random AI.

   153

 * @param forced_ai the AI to force.

   154

 */

   155

void AI_ForceAI(const char *forced_ai)

   156

{

   157

	free(_forced_ai_name);

   158

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

   159

}

   160

   161

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

   162

{

   163

	return _ai_squirrel->GetAIConsoleList(p, last);

   164

}

   165

   166

AIInfo *AI_GetPlayerInfo(PlayerID player)

   167

{

   168

	return _ai_info[player];

   169

}

   170

   171

/**

   173

 */

   175

{

   176

	const Player* p;

   177

   178

	FOR_ALL_PLAYERS(p) {

   179

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

   180

	}

   182

   189

	delete _ai_squirrel;

   190

	_ai_squirrel = NULL;

   191

}

   192

   193

/**

   194

 * Is it allowed to start a new AI.

   195

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

   196

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

   197

 */

   198

bool AI_AllowNewAI()

   199

{

   200

	/* If disabled, no AI */

   201

	if (!_ai_enabled) return false;

   202

   203

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

   204

	if (_networking && !_network_server) return false;

   205

   206

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

   207

	if (_networking && _network_server) {

   208

		/* Do we want AIs in multiplayer? */

   209

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

   210

	}

   211

   212

	return true;

   213

}

   214

   215

#else /* NO_THREADS */

   216

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

   217

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

   218

void AI_PlayerDied(PlayerID player) {}

   219

void AI_RunGameLoop() {}

   220

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

   221

void AI_Initialize() {}

   222

void AI_Uninitialize() {}

   223

bool AI_AllowNewAI() { return false; }

   224

void AI_ForceAI(const char *forced_ai) {}

   225

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

   226

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

   227

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

   228

#endif /* NO_THREADS */