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

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

    14

    15

class AIController;

    16

    17

class AIFactoryBase {

    18

private:

    19

	char *name;

    20

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

    21

    22

	static Factories &GetFactories()

    23

	{

    24

		static Factories &s_factories = *new Factories();

    25

		return s_factories;

    26

	}

    27

    28

protected:

    29

	/**

    30

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

    31

	 */

    32

	void RegisterFactory(const char *name)

    33

	{

    34

		/* Don't register nameless Factories */

    35

		if (name == NULL) return;

    36

    37

		this->name = strdup(name);

    38

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

    39

		assert(P.second);

    40

	}

    41

    42

public:

    43

	AIFactoryBase() :

    44

		name(NULL)

    45

	{}

    46

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

    47

    48

	/**

    49

	 * Run all initializers.

    50

	 */

    51

	static void RunInitializers()

    52

	{

    53

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

    54

		static bool run_once = false;

    55

		if (run_once) return;

    56

		run_once = true;

    57

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

    58

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

    59

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

    60

			AIFactoryBase *f = (*it).second;

    61

			f->Initializer();

    62

		}

    63

	}

    64

    65

	/**

    66

	 * Select a random AI from all known AIs.

    67

	 */

    69

	{

    70

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

    71

    72

		/* Find a random AI */

    73

		uint i;

    74

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

    75

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

    76

    77

		/* Find the Nth item from the array */

    78

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

    79

		Factories::iterator first_it;

    80

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

    81

		first_it = it;

    82

		AIFactoryBase *f = it->second;

    83

    84

		if (!f->AllowStartup()) {

    85

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

    86

			do {

    87

				it++;

    88

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

    89

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

    90

				if (first_it == it) break;

    91

				f = it->second;

    92

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

    93

			/* Unable to start any AI */

    94

			if (first_it == it) return NULL;

    95

		}

    97

	}

    98

    99

	/**

   100

	 * Select the AI with the given name.

   101

	 * @param name the AI to select.

   102

	 */

   104

	{

   105

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

   106

   107

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

   108

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

   109

			AIFactoryBase *f = (*it).second;

   110

   111

			if (strcasecmp(name, f->name) == 0 && f->AllowStartup()) {

   113

			}

   114

		}

   115

   116

		return NULL;

   117

	}

   118

   119

	/**

   120

	 * Fills the given buffer with the AIs we know.

   121

	 * @param p    start of the buffer.

   122

	 * @param last till were we may write.

   123

	 * @return till were we have written.

   124

	 */

   125

	static char *GetAIConsoleList(char *p, const char *last)

   126

	{

   127

		p += snprintf(p, last - p, "List of AIs:\n");

   128

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

   129

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

   130

			AIFactoryBase *f = (*it).second;

   131

			if (!f->AllowStartup()) continue;

   132

			p += snprintf(p, last - p, "%10s: %s\n", f->name, f->GetDescription());

   133

		}

   134

		p += snprintf(p, last - p, "\n");

   135

   136

		return p;

   137

	}

   138

   139

   144

   145

	/**

   146

	 * Get the author of the AI.

   147

	 */

   148

	virtual const char *GetAuthor() = 0;

   149

   150

	/**

   151

	 * Get a description of the AI.

   152

	 */

   153

	virtual const char *GetDescription() = 0;

   154

   155

	/**

   156

	 * Get the version of this AI.

   157

	 */

   158

	virtual int GetVersion() = 0;

   159

   160

	/**

   161

	 * Get the date of the version.

   162

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

   163

	 */

   164

	virtual const char *GetDate() = 0;

   165

   166

	/**

   167

	 * Create an instance of your AI.

   168

	 */

   169

	virtual AIController *CreateInstance() = 0;

   170

   171

	/**

   172

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

   173

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

   174

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

   175

	 */

   176

	virtual bool AllowStartup() { return true; }

   177

   178

	/**

   179

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

   180

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

   181

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

   182

	 *  constructor). Then you can use this function.

   183

	 * @note Avoid using it!

   184

	 */

   185

	virtual void Initializer() { }

   186

};

   187

   188

/**

   189

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

   190

 *  works correctly on initialization.

   191

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

   192

 */

   193

template <class T>

   194

class AIFactory: public AIFactoryBase {

   195

public:

   196

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

   197

   198

	/**

   199

	 * Get a short name for the AI.

   200

	 */

   201

	const char *GetName();

   202

};

   203

   204

#endif /* AI_FACTORY_HPP */