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

    12

#include "ai_base.hpp"

    14

    15

static AIController *_ai_player[MAX_PLAYERS];

    16

static uint _ai_frame_counter;

    17

static bool _ai_enabled;

    18

    19

/**

    20

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

    21

 */

    22

static void AI_RunTick(PlayerID player)

    23

{

    24

	_current_player = player;

    25

    26

	_ai_player[player]->IncreaseTick();

    27

	_ai_player[player]->GameLoop();

    28

}

    29

    30

    31

/**

    32

 * The gameloop for AIs.

    33

 *  Handles one tick for all the AIs.

    34

 */

    35

void AI_RunGameLoop()

    36

{

    37

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

    38

	if (!_ai_enabled) return;

    39

    40

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

    41

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

    42

    43

	/* New tick */

    44

	_ai_frame_counter++;

    45

    46

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

    47

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

    48

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

    49

    50

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

    51

	if (!_networking || _network_server) {

    52

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

    53

		const Player* p;

    54

    55

		FOR_ALL_PLAYERS(p) {

    56

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

    57

				/* Run the script */

    58

				AI_RunTick(p->index);

    59

			}

    60

		}

    61

	}

    62

    63

	_current_player = OWNER_NONE;

    64

}

    65

    66

/**

    67

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

    68

 */

    69

void AI_StartNewAI(PlayerID player)

    70

{

    71

	assert(IsValidPlayer(player));

    72

	if (!_ai_enabled) return;

    73

	if (_networking && !_network_server) return;

    74

    75

	/* Called if a new AI is booted */

    77

}

    78

    79

/**

    80

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

    81

 */

    82

void AI_PlayerDied(PlayerID player)

    83

{

    84

	if (!_ai_enabled) return;

    85

    86

	/* Called if this AI died */

    87

	delete _ai_player[player];

    88

}

    89

    90

/**

    91

 * Initialize some AI-related stuff.

    92

 */

    93

void AI_Initialize()

    94

{

    95

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

    96

	AI_Uninitialize();

    97

    98

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

    99

	_ai_frame_counter = 0;

   100

	_ai_enabled = true;

   101

}

   102

   103

/**

   104

 * Deinitializer for AI-related stuff.

   105

 */

   106

void AI_Uninitialize()

   107

{

   108

	const Player* p;

   109

   110

	FOR_ALL_PLAYERS(p) {

   111

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

   112

	}

   113

}

   114

   115

/**

   116

 * Is it allowed to start a new AI.

   117

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

   118

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

   119

 */

   120

bool AI_AllowNewAI()

   121

{

   122

	/* If disabled, no AI */

   123

	if (!_ai_enabled) return false;

   124

   125

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

   126

	if (_networking && !_network_server) return false;

   127

   128

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

   129

	if (_networking && _network_server) {

   130

		/* Do we want AIs in multiplayer? */

   131

		if (!_patches.ai_in_multiplayer) return false;

   132

	}

   133

   134

	return true;

   135

}