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 "ai.h"

    18

#include "ai_threads.h"

    19

#include "ai_factory.hpp"

    20

#include "api/ai_base.hpp"

    21

#include "api/ai_controller.hpp"

    22

#include "../signal_func.h"

    23

    24

static AIController *_ai_player[MAX_PLAYERS];

    25

static AIFactoryBase *_ai_factory[MAX_PLAYERS];

    26

static uint _ai_frame_counter;

    27

static bool _ai_enabled;

    28

static char *_forced_ai_name = NULL;

    29

    30

/**

    31

 * The gameloop for AIs.

    32

 *  Handles one tick for all the AIs.

    33

 */

    34

void AI_RunGameLoop()

    35

{

    36

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

    37

	if (!_ai_enabled) return;

    38

    39

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

    40

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

    41

    42

	/* New tick */

    43

	_ai_frame_counter++;

    44

    45

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

    46

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

    47

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

    48

    49

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

    50

	if (!_networking || _network_server) {

    51

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

    52

		const Player *p;

    53

    54

		FOR_ALL_PLAYERS(p) {

    55

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

    56

				/* Run the script */

    57

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

    58

				_current_player = p->index;

    59

				AI_RunTick(p->index);

    60

			}

    61

		}

    62

	}

    63

    64

	_current_player = OWNER_NONE;

    65

}

    66

    67

void AI_Event(PlayerID player, AIEvent *event)

    68

{

    69

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

    71

    72

	PlayerID old_player = _current_player;

    73

	_current_player = player;

    74

	AIEventController::InsertEvent(event);

    75

	_current_player = old_player;

    76

}

    77

    78

/**

    79

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

    80

 */

    81

void AI_StartNewAI(PlayerID player)

    82

{

    83

	assert(IsValidPlayer(player));

    84

	if (!_ai_enabled) return;

    85

	if (_networking && !_network_server) return;

    86

    87

	AIFactoryBase *factory;

    88

	if (_forced_ai_name == NULL) {

    89

		factory = AIFactoryBase::SelectRandomAI();

    90

	} else {

    91

		factory = AIFactoryBase::SelectAI(_forced_ai_name);

    92

	}

    93

	if (factory == NULL) {

    94

		if (_forced_ai_name == NULL) {

    95

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

    96

		} else {

    97

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

    98

		}

    99

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

   100

		return;

   101

	}

   102

   103

	_ai_factory[player] = factory;

   104

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

   105

	_current_player = player;

   106

	AIObject::ResetInternalPlayerData();

   107

	AI_StartPlayer(player, _ai_player[player]);

   108

}

   109

   110

/**

   111

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

   112

 */

   113

void AI_PlayerDied(PlayerID player)

   114

{

   115

	if (!_ai_enabled) return;

   116

   117

	_current_player = player;

   118

	AI_StopPlayer(player);

   119

	/* Called if this AI died */

   120

	delete _ai_player[player];

   121

	_ai_player[player] = NULL;

   122

	_ai_factory[player] = NULL;

   123

}

   124

   125

/**

   126

 * Initialize some AI-related stuff.

   127

 */

   128

void AI_Initialize()

   129

{

   130

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

   131

	AI_Uninitialize();

   132

   133

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

   134

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

   135

	_ai_frame_counter = 0;

   136

	_ai_enabled = true;

   137

   138

	AIFactoryBase::RunInitializers();

   139

}

   140

   141

/**

   142

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

   143

 * Pass NULL to use a random AI.

   144

 * @param forced_ai the AI to force.

   145

 */

   146

void AI_ForceAI(const char *forced_ai)

   147

{

   148

	free(_forced_ai_name);

   149

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

   150

}

   151

   152

AIFactoryBase *AI_GetPlayerFactory(PlayerID player)

   153

{

   154

	return _ai_factory[player];

   155

}

   156

   157

/**

   158

 * Deinitializer for AI-related stuff.

   159

 */

   160

void AI_Uninitialize()

   161

{

   162

	const Player* p;

   163

   164

	FOR_ALL_PLAYERS(p) {

   165

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

   166

	}

   167

}

   168

   169

/**

   170

 * Is it allowed to start a new AI.

   171

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

   172

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

   173

 */

   174

bool AI_AllowNewAI()

   175

{

   176

	/* If disabled, no AI */

   177

	if (!_ai_enabled) return false;

   178

   179

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

   180

	if (_networking && !_network_server) return false;

   181

   182

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

   183

	if (_networking && _network_server) {

   184

		/* Do we want AIs in multiplayer? */

   185

		if (!_patches.ai_in_multiplayer) return false;

   186

	}

   187

   188

	return true;

   189

}

   190

   191

#else /* NO_THREADS */

   192

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

   193

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

   194

void AI_PlayerDied(PlayerID player) {}

   195

void AI_RunGameLoop() {}

   196

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

   197

void AI_Initialize() {}

   198

void AI_Uninitialize() {}

   199

bool AI_AllowNewAI() { return false; }

   200

void AI_ForceAI(const char *forced_ai) {}

   201

AIFactoryBase *AI_GetPlayerFactory(PlayerID player) { return NULL; }

   202

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

   203

#endif /* NO_THREADS */