1

/* $Id$ */

     2

     3

/** @file ai_controler.hpp declaration of class for AIController class */

     4

     5

#ifndef AI_CONTROLLER_HPP

     6

#define AI_CONTROLLER_HPP

     7

     8

#include "../../stdafx.h"

     9

    10

/**

    11

 * Class that handles the core of every AI. Each AI needs to extend this class

    12

 *  in order to work. The OpenTTD core makes sure GetTick gets increased when

    13

 *  needed.

    14

 */

    15

class AIController {

    16

private:

    17

	uint tick;

    18

    19

public:

    20

	/**

    21

	 * Initializer of the AIController.

    22

	 */

    23

	AIController() :

    24

		tick(0)

    25

	{}

    26

    27

	/**

    28

	 * Destructor of the AIController.

    29

	 */

    30

	virtual ~AIController() { }

    31

    32

	/**

    33

	 * This function is called to start your AI. Your AI starts here. If you

    34

	 *   return from this function, your AI dies, so make sure that doesn't

    35

	 *   happen. It is okay to use while() {} loops, as long as you put a

    36

	 *   Sleep() in it to give the rest of the game time to do things. Also

    37

	 *   don't keep the system busy for too long, as people will consider

    38

	 *   that annoying.

    39

	 * @note Cannot be called from within your AI.

    40

	 */

    41

	virtual void Start() = 0;

    42

    43

	/**

    44

	 * When this function is called, the AI must stop as soon as possible.

    45

	 *   It may not call any function that might suspend, like DoCommand()

    46

	 *   and Sleep().

    47

	 * @note Cannot be called from within your AI.

    48

	 */

    49

	virtual void Stop() = 0;

    50

    51

	/**

    52

	 * Increase the internal ticker. You should never call this yourself,

    53

	 *   as it is called by the OpenTTD system itself.

    54

	 * @note Cannot be called from within your AI.

    55

	 */

    56

	void IncreaseTick() { this->tick++; }

    57

    58

	/**

    59

	 * Find at which tick your AI currently is.

    60

	 * @return returns the current tick.

    61

	 */

    62

	uint GetTick() { return this->tick; }

    63

    64

	/**

    65

	 * Sleep for X ticks. The code continues after this line when the X AI ticks

    66

	 *   are passed. Mind that an AI tick is different from in-game ticks and

    67

	 *   differ per AI speed.

    68

	 * @param ticks the ticks to wait

    69

	 * @post the value of GetTick() will be changed exactly 'ticks' in value after

    70

	 *   calling this.

    71

	 */

    72

	void Sleep(uint ticks);

    73

};

    74

    75

#endif /* AI_CONTROLLER_HPP */

    76

    77

/*

    78

 * The next part of the code is outside of the multiple inclusions

    79

 * protection. This is done because the Squirrel code needs the

    80

 * AIController class declaration to make the Squirrel registration

    81

 * functions. So in the first include DEFINE_SQUIRREL_CLASS is not

    82

 * defined, but in the second one it will when included from the

    83

 * Squirrel AI implementation.

    84

 * All other instances that include this header twice must not have

    85

 * set DEFINE_SQUIRREL_CLASS, so this part will not be included

    86

 * twice under those circumstances.

    87

 */

    88

    89

#ifdef DEFINE_SQUIRREL_CLASS

    90

void SQAIControllerRegister(Squirrel *engine) {

    91

	DefSQClass <AIControllerSquirrel> SQAIController("AIController");

    92

	SQAIController.PreRegister(engine);

    93

	SQAIController.DefSQMethod(engine, &AIControllerSquirrel::GetTick, "GetTick");

    94

	SQAIController.DefSQMethod(engine, &AIControllerSquirrel::Sleep,   "Sleep");

    95

	SQAIController.PostRegister(engine);

    96

}

    97

#endif /* DEFINE_SQUIRREL_CLASS */