1

/* $Id$ */

     2

     3

#ifndef AI_H

     4

#define AI_H

     5

     6

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

     7

#include "../player.h"

     8

#include "../command_type.h"

    10

    11

/* How DoCommands look like for an AI */

    12

struct AICommand {

    13

	uint32 tile;

    14

	uint32 p1;

    15

	uint32 p2;

    16

	uint32 procc;

    17

	CommandCallback *callback;

    18

    19

	char *text;

    20

	uint uid;

    21

    22

	AICommand *next;

    23

};

    24

    25

/* The struct for an AIScript Player */

    26

struct AIPlayer {

    27

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

    28

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

    29

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

    30

};

    31

    32

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

    33

struct AIStruct {

    34

	/* General */

    35

	bool enabled;           ///< Is AI enabled?

    36

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

    37

};

    38

    39

VARDEF AIStruct _ai;

    40

VARDEF AIPlayer _ai_player[MAX_PLAYERS];

    41

    42

// ai.c

    43

void AI_StartNewAI(PlayerID player);

    44

void AI_PlayerDied(PlayerID player);

    45

void AI_RunGameLoop();

    46

void AI_Initialize();

    47

void AI_Uninitialize();

    48

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

    49

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

    50

    51

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

    52

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

    53

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

    54

 */

    55

static inline bool AI_AllowNewAI()

    56

{

    57

	/* If disabled, no AI */

    58

	if (!_ai.enabled)

    59

		return false;

    60

    61

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

    62

	if (_networking && !_network_server)

    63

		return false;

    64

    65

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

    66

	if (_networking && _network_server) {

    67

		/* Do we want AIs in multiplayer? */

    68

		if (!_patches.ai_in_multiplayer)

    69

			return false;

    70

    71

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

    72

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

    73

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

    74

		 *  is really executed... */

    75

		if (!_patches.ainew_active)

    76

			return false;

    77

	}

    78

    79

	return true;

    80

}

    81

    82

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

    83

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

    84

    85

/**

    86

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

    87

 */

    88

static inline uint AI_RandomRange(uint max)

    89

{

    90

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

    91

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

    92

	 */

    93

	if (_networking)

    94

		return InteractiveRandomRange(max);

    95

	else

    96

		return RandomRange(max);

    97

}

    98

    99

/**

   100

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

   101

 */

   102

static inline uint32 AI_Random()

   103

{

   104

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

   105

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

   106

	 */

   107

	if (_networking)

   108

		return InteractiveRandom();

   109

	else

   110

		return Random();

   111

}

   112

   113

#endif /* AI_H */