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_base.hpp"

    14

#include "ai_controller.hpp"

    15

#include "ai_factory.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;

    30

    31

	_ai_player[player]->IncreaseTick();

    32

	_ai_player[player]->GameLoop();

    33

}

    34

    35

    36

/**

    37

 * The gameloop for AIs.

    38

 *  Handles one tick for all the AIs.

    39

 */

    40

void AI_RunGameLoop()

    41

{

    42

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

    43

	if (!_ai_enabled) return;

    44

    45

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

    46

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

    47

    48

	/* New tick */

    49

	_ai_frame_counter++;

    50

    51

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

    52

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

    53

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

    54

    55

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

    56

	if (!_networking || _network_server) {

    57

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

    58

		const Player* p;

    59

    60

		FOR_ALL_PLAYERS(p) {

    61

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

    62

				/* Run the script */

    63

				AI_RunTick(p->index);

    64

			}

    65

		}

    66

	}

    67

    68

	_current_player = OWNER_NONE;

    69

}

    70

    71

/**

    72

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

    73

 */

    74

void AI_StartNewAI(PlayerID player)

    75

{

    76

	assert(IsValidPlayer(player));

    77

	if (!_ai_enabled) return;

    78

	if (_networking && !_network_server) return;

    79

    80

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

    81

	if (_ai_player[player] == NULL) {

    82

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

    83

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

    84

	}

    85

}

    86

    87

/**

    88

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

    89

 */

    90

void AI_PlayerDied(PlayerID player)

    91

{

    92

	if (!_ai_enabled) return;

    93

    94

	/* Called if this AI died */

    95

	delete _ai_player[player];

    96

}

    97

    98

/**

    99

 * Initialize some AI-related stuff.

   100

 */

   101

void AI_Initialize()

   102

{

   103

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

   104

	AI_Uninitialize();

   105

   106

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

   107

	_ai_frame_counter = 0;

   108

	_ai_enabled = true;

   109

   110

	AIFactoryBase::RunInitializers();

   111

}

   112

   113

/**

   114

 * Deinitializer for AI-related stuff.

   115

 */

   116

void AI_Uninitialize()

   117

{

   118

	const Player* p;

   119

   120

	FOR_ALL_PLAYERS(p) {

   121

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

   122

	}

   123

}

   124

   125

/**

   126

 * Is it allowed to start a new AI.

   127

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

   128

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

   129

 */

   130

bool AI_AllowNewAI()

   131

{

   132

	/* If disabled, no AI */

   133

	if (!_ai_enabled) return false;

   134

   135

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

   136

	if (_networking && !_network_server) return false;

   137

   138

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

   139

	if (_networking && _network_server) {

   140

		/* Do we want AIs in multiplayer? */

   141

		if (!_patches.ai_in_multiplayer) return false;

   142

	}

   143

   144

	return true;

   145

}