1

/* $Id$ */

     2

     3

/** @file ai.h Base functions for all AIs. */

     4

     5

#ifndef AI_H

     6

#define AI_H

     7

     8

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

     9

#include "../command_type.h"

    10

#include "../core/random_func.hpp"

    11

#include "../settings_type.h"

    12

    13

/* How DoCommands look like for an AI */

    14

struct AICommand {

    15

	uint32 tile;

    16

	uint32 p1;

    17

	uint32 p2;

    18

	uint32 procc;

    19

	CommandCallback *callback;

    20

    21

	char *text;

    22

	uint uid;

    23

    24

	AICommand *next;

    25

};

    26

    27

/* The struct for an AIScript Company */

    28

struct AICompany {

    29

	bool active;            ///< Is this AI active?

    30

	AICommand *queue;       ///< The commands that he has in his queue

    31

	AICommand *queue_tail;  ///< The tail of this queue

    32

};

    33

    34

/* The struct to keep some data about the AI in general */

    35

struct AIStruct {

    36

	/* General */

    37

	bool enabled;           ///< Is AI enabled?

    38

	uint tick;              ///< The current tick (something like _frame_counter, only for AIs)

    39

};

    40

    41

extern AIStruct _ai;

    42

extern AICompany _ai_company[MAX_COMPANIES];

    43

    44

// ai.c

    45

void AI_StartNewAI(CompanyID company);

    46

void AI_CompanyDied(CompanyID company);

    47

void AI_RunGameLoop();

    48

void AI_Initialize();

    49

void AI_Uninitialize();

    50

CommandCost AI_DoCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc);

    51

CommandCost AI_DoCommandCc(TileIndex tile, uint32 p1, uint32 p2, uint32 flags, uint procc, CommandCallback* callback);

    52

    53

/** Is it allowed to start a new AI.

    54

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

    55

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

    56

 */

    57

static inline bool AI_AllowNewAI()

    58

{

    59

	/* If disabled, no AI */

    60

	if (!_ai.enabled)

    61

		return false;

    62

    63

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

    64

	if (_networking && !_network_server)

    65

		return false;

    66

    67

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

    68

	if (_networking && _network_server) {

    69

		/* Do we want AIs in multiplayer? */

    70

		if (!_settings_game.ai.ai_in_multiplayer)

    71

			return false;

    72

    73

		/* Only the NewAI is allowed... sadly enough the old AI just doesn't support this

    74

		 *  system, because all commands are delayed by at least 1 tick, which causes

    75

		 *  a big problem, because it uses variables that are only set AFTER the command

    76

		 *  is really executed... */

    77

		if (!_settings_game.ai.ainew_active)

    78

			return false;

    79

	}

    80

    81

	return true;

    82

}

    83

    84

#define AI_CHANCE16(a, b)    ((uint16)     AI_Random()  <= (uint16)((65536 * a) / b))

    85

#define AI_CHANCE16R(a, b, r) ((uint16)(r = AI_Random()) <= (uint16)((65536 * a) / b))

    86

    87

/**

    88

 * The random-function that should be used by ALL AIs.

    89

 */

    90

static inline uint AI_RandomRange(uint max)

    91

{

    92

	/* We pick RandomRange if we are in SP (so when saved, we do the same over and over)

    93

	 *   but we pick InteractiveRandomRange if we are a network_server or network-client.

    94

	 */

    95

	if (_networking)

    96

		return InteractiveRandomRange(max);

    97

	else

    98

		return RandomRange(max);

    99

}

   100

   101

/**

   102

 * The random-function that should be used by ALL AIs.

   103

 */

   104

static inline uint32 AI_Random()

   105

{

   106

/* We pick RandomRange if we are in SP (so when saved, we do the same over and over)

   107

	 *   but we pick InteractiveRandomRange if we are a network_server or network-client.

   108

	 */

   109

	if (_networking)

   110

		return InteractiveRandom();

   111

	else

   112

		return Random();

   113

}

   114

   115

#endif /* AI_H */