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

     9

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

    10

#include "../helpers.hpp"

    11

#include "../debug.h"

    12

    13

#ifndef NO_THREADS

    14

#include "ai.h"

    15

#include "ai_threads.h"

    16

#include "ai_factory.hpp"

    17

#include "api/ai_base.hpp"

    18

#include "api/ai_controller.hpp"

    19

    20

static AIController *_ai_player[MAX_PLAYERS];

    21

static uint _ai_frame_counter;

    22

static bool _ai_enabled;

    23

static char *_forced_ai_name = NULL;

    24

    25

/**

    26

 * The gameloop for AIs.

    27

 *  Handles one tick for all the AIs.

    28

 */

    29

void AI_RunGameLoop()

    30

{

    31

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

    32

	if (!_ai_enabled) return;

    33

    34

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

    35

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

    36

    37

	/* New tick */

    38

	_ai_frame_counter++;

    39

    40

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

    41

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

    42

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

    43

    44

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

    45

	if (!_networking || _network_server) {

    46

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

    47

		const Player* p;

    48

    49

		FOR_ALL_PLAYERS(p) {

    50

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

    51

				/* Run the script */

    52

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

    53

				_current_player = p->index;

    54

				AI_RunTick(p->index);

    55

			}

    56

		}

    57

	}

    58

    59

	_current_player = OWNER_NONE;

    60

}

    61

    62

/**

    63

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

    64

 */

    65

void AI_StartNewAI(PlayerID player)

    66

{

    67

	assert(IsValidPlayer(player));

    68

	if (!_ai_enabled) return;

    69

	if (_networking && !_network_server) return;

    70

    71

	if (_forced_ai_name == NULL) {

    72

		_ai_player[player] = AIFactoryBase::SelectRandomAI();

    73

	} else {

    74

		_ai_player[player] = AIFactoryBase::SelectAI(_forced_ai_name);

    75

	}

    76

	if (_ai_player[player] == NULL) {

    77

		if (_forced_ai_name == NULL) {

    78

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

    79

		} else {

    80

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

    81

		}

    82

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

    83

		return;

    84

	}

    85

	_current_player = player;

    86

	AIObject::ResetInternalPlayerData();

    87

	AI_StartPlayer(player, _ai_player[player]);

    88

}

    89

    90

/**

    91

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

    92

 */

    93

void AI_PlayerDied(PlayerID player)

    94

{

    95

	if (!_ai_enabled) return;

    96

    98

	AI_StopPlayer(player);

    99

	/* Called if this AI died */

   100

	delete _ai_player[player];

   101

	_ai_player[player] = NULL;

   102

}

   103

   104

/**

   105

 * Initialize some AI-related stuff.

   106

 */

   107

void AI_Initialize()

   108

{

   109

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

   110

	AI_Uninitialize();

   111

   112

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

   113

	_ai_frame_counter = 0;

   114

	_ai_enabled = true;

   115

   116

	AIFactoryBase::RunInitializers();

   117

}

   118

   119

/**

   120

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

   121

 * Pass NULL to use a random AI.

   122

 * @param forced_ai the AI to force.

   123

 */

   124

void AI_ForceAI(const char *forced_ai)

   125

{

   126

	free(_forced_ai_name);

   127

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

   128

}

   129

   130

   131

/**

   132

 * Deinitializer for AI-related stuff.

   133

 */

   134

void AI_Uninitialize()

   135

{

   136

	const Player* p;

   137

   138

	FOR_ALL_PLAYERS(p) {

   139

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

   140

	}

   141

}

   142

   143

/**

   144

 * Is it allowed to start a new AI.

   145

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

   146

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

   147

 */

   148

bool AI_AllowNewAI()

   149

{

   150

	/* If disabled, no AI */

   151

	if (!_ai_enabled) return false;

   152

   153

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

   154

	if (_networking && !_network_server) return false;

   155

   156

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

   157

	if (_networking && _network_server) {

   158

		/* Do we want AIs in multiplayer? */

   159

		if (!_patches.ai_in_multiplayer) return false;

   160

	}

   161

   162

	return true;

   163

}

   164

   165

#else /* NO_THREADS */

   166

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

   167

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

   168

void AI_PlayerDied(PlayerID player) {}

   169

void AI_RunGameLoop() {}

   170

void AI_Initialize() {}

   171

void AI_Uninitialize() {}

   172

bool AI_AllowNewAI() { return false; }

   173

void AI_ForceAI(const char *forced_ai) {}

   174

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

   175

#endif /* NO_THREADS */