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 = *new 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

		/* Don't register nameless Factories */

    34

		if (name == NULL) return;

    35

    36

		this->name = name;

    37

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

    38

		assert(P.second);

    39

	}

    40

    41

public:

    42

	AIFactoryBase() :

    43

		name(NULL)

    44

	{}

    45

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

    46

    47

	/**

    48

	 * Run all initializers.

    49

	 */

    50

	static void RunInitializers()

    51

	{

    52

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

    53

		static bool run_once = false;

    54

		if (run_once) return;

    55

		run_once = true;

    56

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

    57

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

    58

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

    59

			AIFactoryBase *f = (*it).second;

    60

			f->Initializer();

    61

		}

    62

	}

    63

    64

	/**

    65

	 * Select a random AI from all known AIs.

    66

	 */

    67

	static AIController *SelectRandomAI()

    68

	{

    69

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

    70

    71

		/* Find a random AI */

    72

		uint i;

    73

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

    74

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

    75

    76

		/* Find the Nth item from the array */

    77

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

    78

		Factories::iterator first_it;

    79

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

    80

		first_it = it;

    81

		AIFactoryBase *f = it->second;

    82

    83

		if (!f->AllowStartup()) {

    84

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

    85

			do {

    86

				it++;

    87

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

    88

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

    89

				if (first_it == it) break;

    90

				f = it->second;

    91

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

    92

			/* Unable to start any AI */

    93

			if (first_it == it) return NULL;

    94

		}

    95

		return f->CreateInstance();

    96

	}

    97

   139

   140

   141

	/**

   142

	 * Get the author of the AI.

   143

	 */

   144

	virtual const char *GetAuthor() = 0;

   145

   146

	/**

   147

	 * Get a description of the AI.

   148

	 */

   149

	virtual const char *GetDescription() = 0;

   150

   151

	/**

   152

	 * Get the version of this AI.

   153

	 */

   154

	virtual int GetVersion() = 0;

   155

   156

	/**

   157

	 * Get the date of the version.

   158

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

   159

	 */

   160

	virtual const char *GetDate() = 0;

   161

   162

	/**

   163

	 * Create an instance of your AI.

   164

	 */

   165

	virtual AIController *CreateInstance() = 0;

   166

   167

	/**

   168

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

   169

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

   170

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

   171

	 */

   172

	virtual bool AllowStartup() { return true; }

   173

   174

	/**

   175

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

   176

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

   177

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

   178

	 *  constructor). Then you can use this function.

   179

	 * @note Avoid using it!

   180

	 */

   181

	virtual void Initializer() { }

   182

};

   183

   184

/**

   185

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

   186

 *  works correctly on initialization.

   187

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

   188

 */

   189

template <class T>

   190

class AIFactory: public AIFactoryBase {

   191

public:

   192

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

   193

   194

	/**

   195

	 * Get a short name for the AI.

   196

	 */

   197

	const char *GetName();

   198

};

   199

   200

#endif /* AI_FACTORY_HPP */