1

#ifndef AI_H

     2

#define AI_H

     3

     4

#include "../functions.h"

     5

#include "../network.h"

     6

#ifdef GPMI

     7

#include <gpmi.h>

     8

#endif /* GPMI */

     9

    10

/* How DoCommands look like for an AI */

    11

typedef struct AICommand {

    12

	uint32 tile;

    13

	uint32 p1;

    14

	uint32 p2;

    15

	uint32 procc;

    16

    17

	uint32 dp[20];

    18

    19

	struct AICommand *next;

    20

} AICommand;

    21

    22

/* The struct for an AIScript Player */

    23

typedef struct AIPlayer {

    24

	bool active;            //! Is this AI active?

    25

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

    26

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

    27

#ifdef GPMI

    28

	gpmi_module *module;    //! The link to the GPMI module

    29

#endif /* GPMI */

    30

} AIPlayer;

    31

    32

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

    33

typedef 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

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

    39

	bool network_client;    //! Are we a network_client?

    40

	uint8 network_playas;   //! The current network player we are connected as

    41

    42

	bool gpmi;              //! True if we want GPMI AIs

    43

#ifdef GPMI

    44

	gpmi_module *gpmi_mod;  //! The module controller for GPMI based AIs (Event-handling)

    45

	gpmi_package *gpmi_pkg; //! The package controller for GPMI based AIs (Functions)

    46

	char gpmi_param[128];   //! The params given to the gpmi_mod

    47

#endif /* GPMI */

    48

} AIStruct;

    49

    50

VARDEF AIStruct _ai;

    51

VARDEF AIPlayer _ai_player[MAX_PLAYERS];

    52

    53

// ai.c

    54

void AI_StartNewAI(PlayerID player);

    55

void AI_PlayerDied(PlayerID player);

    56

void AI_RunGameLoop(void);

    57

void AI_Initialize(void);

    58

void AI_Uninitialize(void);

    59

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

    60

    61

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

    62

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

    63

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

    64

 */

    65

static inline bool AI_AllowNewAI(void)

    66

{

    67

	/* If disabled, no AI */

    68

	if (!_ai.enabled)

    69

		return false;

    70

    71

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

    72

	if (_networking && !_network_server)

    73

		return false;

    74

    75

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

    76

	if (_networking && _network_server) {

    77

		/* Do we want AIs in multiplayer? */

    78

		if (!_patches.ai_in_multiplayer)

    79

			return false;

    80

    81

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

    82

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

    83

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

    84

		 *  is really executed... */

    85

		if (!_patches.ainew_active && !_ai.gpmi)

    86

			return false;

    87

	}

    88

    89

	return true;

    90

}

    91

    92

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

    93

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

    94

    95

/**

    96

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

    97

 */

    98

static inline uint AI_RandomRange(uint max)

    99

{

   100

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

   101

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

   102

	 */

   103

	if (_networking)

   104

		return InteractiveRandomRange(max);

   105

	else

   106

		return RandomRange(max);

   107

}

   108

   109

/**

   110

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

   111

 */

   112

static inline uint32 AI_Random(void)

   113

{

   114

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

   115

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

   116

	 */

   117

	if (_networking)

   118

		return InteractiveRandom();

   119

	else

   120

		return Random();

   121

}

   122

   123

#endif /* AI_H */