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

#include "ai.h"

    13

#include "ai_factory.hpp"

    14

#include "api/ai_base.hpp"

    15

#include "api/ai_controller.hpp"

    16

    17

static AIController *_ai_player[MAX_PLAYERS];

    18

static uint _ai_frame_counter;

    19

static bool _ai_enabled;

    20

    21

/**

    22

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

    23

 */

    24

static void AI_RunTick(PlayerID player)

    25

{

    26

	_current_player = player;

    27

    28

	/* If this is NULL, it means we couldn't find an AI for this player */

    29

	if (_ai_player[player] == NULL) return;

    31

    32

	_ai_player[player]->IncreaseTick();

    36

}

    37

    38

    39

/**

    40

 * The gameloop for AIs.

    41

 *  Handles one tick for all the AIs.

    42

 */

    43

void AI_RunGameLoop()

    44

{

    45

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

    46

	if (!_ai_enabled) return;

    47

    48

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

    49

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

    50

    51

	/* New tick */

    52

	_ai_frame_counter++;

    53

    54

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

    55

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

    56

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

    57

    58

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

    59

	if (!_networking || _network_server) {

    60

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

    61

		const Player* p;

    62

    63

		FOR_ALL_PLAYERS(p) {

    64

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

    65

				/* Run the script */

    66

				AI_RunTick(p->index);

    67

			}

    68

		}

    69

	}

    70

    71

	_current_player = OWNER_NONE;

    72

}

    73

    74

/**

    75

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

    76

 */

    77

void AI_StartNewAI(PlayerID player)

    78

{

    79

	assert(IsValidPlayer(player));

    80

	if (!_ai_enabled) return;

    81

	if (_networking && !_network_server) return;

    82

    83

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

    84

	if (_ai_player[player] == NULL) {

    85

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

    86

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

    88

	}

    91

}

    92

    93

/**

    94

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

    95

 */

    96

void AI_PlayerDied(PlayerID player)

    97

{

    98

	if (!_ai_enabled) return;

    99

   101

	/* Called if this AI died */

   102

	delete _ai_player[player];

   103

}

   104

   105

/**

   106

 * Initialize some AI-related stuff.

   107

 */

   108

void AI_Initialize()

   109

{

   110

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

   111

	AI_Uninitialize();

   112

   113

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

   114

	_ai_frame_counter = 0;

   115

	_ai_enabled = true;

   116

   117

	AIFactoryBase::RunInitializers();

   118

}

   119

   120

/**

   121

 * Deinitializer for AI-related stuff.

   122

 */

   123

void AI_Uninitialize()

   124

{

   125

	const Player* p;

   126

   127

	FOR_ALL_PLAYERS(p) {

   128

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

   129

	}

   130

}

   131

   132

/**

   133

 * Is it allowed to start a new AI.

   134

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

   135

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

   136

 */

   137

bool AI_AllowNewAI()

   138

{

   139

	/* If disabled, no AI */

   140

	if (!_ai_enabled) return false;

   141

   142

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

   143

	if (_networking && !_network_server) return false;

   144

   145

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

   146

	if (_networking && _network_server) {

   147

		/* Do we want AIs in multiplayer? */

   148

		if (!_patches.ai_in_multiplayer) return false;

   149

	}

   150

   151

	return true;

   152

}