1

/* $Id$ */

     2

     3

/** @file ai_factory.hpp declaration of class for AIFactory class */

     4

     5

#ifndef AI_FACTORY_HPP

     6

#define AI_FACTORY_HPP

     7

     8

#include <string>

     9

#include <map>

    10

#include <assert.h>

    11

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

    12

#include "../../functions.h"

    13

    14

class AIController;

    15

    16

class AIFactoryBase {

    17

private:

    18

	const char *name;

    19

	typedef std::map<std::string, AIFactoryBase *> Factories;

    20

    21

	static Factories &GetFactories()

    22

	{

    23

		static Factories s_factories;

    24

		return s_factories;

    25

	}

    26

    27

protected:

    28

	/**

    29

	 * This registers your AI to the main system so we know about you.

    30

	 */

    31

	void RegisterFactory(const char *name)

    32

	{

    33

		this->name = name;

    34

		/* Don't register nameless Factories */

    35

		if (name == NULL) return;

    36

    37

		std::pair<Factories::iterator, bool> P = GetFactories().insert(Factories::value_type(name, this));

    38

		assert(P.second);

    39

	}

    40

    41

public:

    42

	virtual ~AIFactoryBase() { if (this->name != NULL) GetFactories().erase(this->name); }

    43

    44

	/**

    45

	 * Run all initializers.

    46

	 */

    47

	static void RunInitializers()

    48

	{

    49

		/* Protect this function from being run several times */

    50

		static bool run_once = false;

    51

		if (run_once) return;

    52

		run_once = true;

    53

		if (GetFactories().size() == 0) return;

    54

		Factories::iterator it = GetFactories().begin();

    55

		for (; it != GetFactories().end(); it++) {

    56

			AIFactoryBase *f = (*it).second;

    57

			f->Initializer();

    58

		}

    59

	}

    60

    61

	/**

    62

	 * Select a random AI from all known AIs.

    63

	 */

    64

	static AIController *SelectRandomAI()

    65

	{

    66

		if (GetFactories().size() == 0) return NULL;

    67

    68

		/* Find a random AI */

    69

		uint i;

    70

		if (_networking) i = InteractiveRandomRange(GetFactories().size());

    71

		else             i =            RandomRange(GetFactories().size());

    72

    73

		/* Find the Nth item from the array */

    74

		Factories::iterator it = GetFactories().begin();

    75

		Factories::iterator first_it;

    76

		for (; i > 0; i--) it++;

    77

		first_it = it;

    79

    80

		if (!f->AllowStartup()) {

    81

			/* We can't start this AI, try to find the next best */

    82

			do {

    84

				if (it == GetFactories().end()) it = GetFactories().begin();

    85

				/* Back at the beginning? Drop out! */

    86

				if (first_it == it) break;

    88

			} while (!f->AllowStartup());

    89

			/* Unable to start any AI */

    90

			if (first_it == it) return NULL;

    91

		}

    92

		return f->CreateInstance();

    93

	}

    94

    95

    96

    97

	/**

    98

	 * Get the author of the AI.

    99

	 */

   100

	virtual const char *GetAuthor() = 0;

   101

   102

	/**

   103

	 * Get a description of the AI.

   104

	 */

   105

	virtual const char *GetDescription() = 0;

   106

   107

	/**

   108

	 * Get the version of this AI.

   109

	 */

   110

	virtual int GetVersion() = 0;

   111

   112

	/**

   113

	 * Get the date of the version.

   114

	 * @return A string like '2007-08-29'.

   115

	 */

   116

	virtual const char *GetDate() = 0;

   117

   118

	/**

   119

	 * Create an instance of your AI.

   120

	 */

   121

	virtual AIController *CreateInstance() = 0;

   122

   123

	/**

   124

	 * In this function you can do some very limited querying of the game.

   125

	 *  If you for example only supply road-vehicle-based AI, and RVs are

   126

	 *  disabled, you return 'false', so you won't boot.

   127

	 */

   128

	virtual bool AllowStartup() { return true; }

   129

   130

	/**

   131

	 * Normally you just make a static instance of AIFactory, and you

   132

	 *  will be registered. In very limited cases, like Squirrel-module,

   133

	 *  it is needed to be called when OpenTTD is launched (so not as

   134

	 *  constructor). Then you can use this function.

   135

	 * @note Avoid using it!

   136

	 */

   137

	virtual void Initializer() { }

   138

};

   139

   140

/**

   141

 * The template to define your AIFactory. This makes sure RegisterFactory

   142

 *  works correctly on initialization.

   143

 * Example: class FYourClass: public AIFactory<FYourClass> { }

   144

 */

   145

template <class T>

   146

class AIFactory: public AIFactoryBase {

   147

public:

   148

	AIFactory() { this->RegisterFactory(((T *)this)->GetName()); }

   149

   150

	/**

   151

	 * Get a short name for the AI.

   152

	 */

   153

	const char *GetName();

   154

};

   155

   156

#endif /* AI_FACTORY_HPP */