1

#ifndef AI_H

     2

#define AI_H

     3

     4

#include "../functions.h"

     5

#include "../network.h"

     6

     7

/* How DoCommands look like for an AI */

     8

typedef struct AICommand {

     9

	uint32 tile;

    10

	uint32 p1;

    11

	uint32 p2;

    12

	uint32 procc;

    13

    14

	uint32 dp[20];

    15

    16

	struct AICommand *next;

    17

} AICommand;

    18

    19

/* The struct for an AIScript Player */

    20

typedef struct AIPlayer {

    21

	bool active;            //! Is this AI active?

    22

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

    23

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

    24

} AIPlayer;

    25

    26

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

    27

typedef struct AIStruct {

    28

	/* General */

    29

	bool enabled;           //! Is AI enabled?

    30

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

    31

    32

	/* For network-clients (a OpenTTD client who acts as an AI connected to a server) */

    33

	bool network_client;    //! Are we a network_client?

    35

} AIStruct;

    36

    37

VARDEF AIStruct _ai;

    38

VARDEF AIPlayer _ai_player[MAX_PLAYERS];

    39

    40

// ai.c

    41

void AI_StartNewAI(PlayerID player);

    42

void AI_PlayerDied(PlayerID player);

    43

void AI_RunGameLoop(void);

    44

void AI_Initialize(void);

    45

void AI_Uninitialize(void);

    46

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

    47

    48

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

    49

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

    50

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

    51

 */

    52

static inline bool AI_AllowNewAI(void)

    53

{

    54

	/* If disabled, no AI */

    55

	if (!_ai.enabled)

    56

		return false;

    57

    58

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

    59

	if (_networking && !_network_server)

    60

		return false;

    61

    62

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

    63

	if (_networking && _network_server) {

    64

		/* Do we want AIs in multiplayer? */

    65

		if (!_patches.ai_in_multiplayer)

    66

			return false;

    67

    68

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

    69

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

    70

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

    71

		 *  is really executed... */

    72

		if (!_patches.ainew_active)

    73

			return false;

    74

	}

    75

    76

	return true;

    77

}

    78

    79

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

    80

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

    81

    82

/**

    83

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

    84

 */

    85

static inline uint AI_RandomRange(uint max)

    86

{

    87

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

    88

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

    89

	 */

    90

	if (_networking)

    91

		return InteractiveRandomRange(max);

    92

	else

    93

		return RandomRange(max);

    94

}

    95

    96

/**

    97

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

    98

 */

    99

static inline uint32 AI_Random(void)

   100

{

   101

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

   102

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

   103

	 */

   104

	if (_networking)

   105

		return InteractiveRandom();

   106

	else

   107

		return Random();

   108

}

   109

   110

#endif /* AI_H */