1

/* $Id$ */

     2

     3

/** @file ai_testmode.hpp class to switch the AI to Transaction mode */

     4

     5

#ifndef AI_TRANSACTIONMODE_HPP

     6

#define AI_TRANSACTIONMODE_HPP

     7

     8

#include "ai_object.hpp"

     9

#include <queue>

    10

    11

/**

    12

 * Class to switch current mode to Transaction mode.

    13

 * If you create an instance of this class, the mode will be switched to

    14

 *   Transaction. The original mode is stored and recovered from when ever the

    15

 *   instance is destroyed.

    16

 * In Transaction mode all commands will be tested, and if not fail, queued.

    17

 *   Later on you can execute a queue for real. The Transaction keeps on

    18

 *   recording all commands till it is destructed or execute or stopped.

    19

 * On execute the transaction can return false, because maps change over time.

    20

 *   If this happens you can use the rollback feature to remove all already

    21

 *   built things.

    22

 */

    23

class AITransactionMode : public AIObject {

    24

private:

    25

	struct AITransactionModeCommand {

    26

		TileIndex tile;

    27

		uint32 p1;

    28

		uint32 p2;

    29

		uint procc;

    30

		char *text;

    31

	};

    32

    33

	AIModeProc *last_mode;

    34

	AIObject *last_instance;

    35

	std::queue<AITransactionModeCommand> command_stack;

    36

	std::queue<AITransactionModeCommand> reverse_stack;

    37

	bool stopped;

    38

	int32 costs;

    39

    40

protected:

    41

	/**

    42

	 * The callback proc for Transaction mode.

    43

	 */

    44

	static bool ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, int32 costs);

    45

    46

public:

    47

	/**

    48

	 * Creating instance of this class switches the build mode to Transaction.

    49

	 * @note when the instance is destroyed, he restores the mode that was

    50

	 *   current when the instance was created!

    51

	 */

    52

	AITransactionMode();

    53

    54

	/**

    55

	 * Destroying this instance reset the building mode to the mode it was

    56

	 *   in when the instance was created.

    57

	 */

    58

	~AITransactionMode();

    59

    60

	/**

    61

	 * Execute all recorded commands.

    62

	 * @return false if any command recorded failed to execute. All other

    63

	 *   commands that follow won't be executed either.

    64

	 * @note when Execute() is called, the transaction is stopped (like calling

    65

	 *   Stop() yourself).

    66

	 * @note Execute() is always executed, no matter what mode you gave it in

    67

	 *   the outside world. It forces itself into executing it for real. To add

    68

	 *   it to an other list, use Append().

    69

	 */

    70

	bool Execute();

    71

    72

	/**

    73

	 * Stop recording the commands and switch to the last mode, like the

    74

	 *   instance was destroyed.

    75

	 */

    76

	void Stop();

    77

    78

	/**

    79

	 * Rollbacks rolls the whole transaction back in case Execute() returned

    80

	 *   false. In case Execute() returned true, there won't be anything to roll

    81

	 *   back, so this command will do nothing.

    82

	 * It rolls back all commands by looking up the reverse of every command

    83

	 *   issued and executes that. Of course it can happen that even that fails.

    84

	 *   In that case the problem will be silently ignored.

    85

	 * @note as you might want to get a costs estimate about the rollback first

    86

	 *   you need to make sure you set the right mode yourself!

    87

	 * @note this command isn't finished yet!!

    88

	 */

    89

	void Rollback();

    90

    91

	/**

    92

	 * Get the costs it takes to execute this transaction (on average, real

    93

	 *   numbers can always differ).

    94

	 */

    95

	int32 GetCosts();

    96

    97

	/**

    98

	 * Append one transaction list to an other.

    99

	 * @param transaction the list that will be appended after the instance you call append on.

   100

	 */

   101

	void Append(AITransactionMode *transaction);

   102

};

   103

   104

#ifdef DEFINE_SQUIRREL_CLASS

   105

/* Custom template to allow AITransactionMode-instance as param */

   106

namespace SQConvert {

   107

	template <> AITransactionMode *GetParam(ForceType<AITransactionMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITransactionMode *)instance; }

   108

}; // namespace SQConvert

   109

   110

void SQAITransactionModeRegister(Squirrel *engine) {

   111

	DefSQClass <AITransactionMode> SQAITransactionMode("AITransactionMode");

   112

	SQAITransactionMode.PreRegister(engine);

   113

	SQAITransactionMode.AddConstructor(engine);

   114

	SQAITransactionMode.DefSQFunction(engine, &AITransactionMode::Execute,  "Execute");

   115

	SQAITransactionMode.DefSQFunction(engine, &AITransactionMode::Stop,     "Stop");

   116

	SQAITransactionMode.DefSQFunction(engine, &AITransactionMode::Rollback, "Rollback");

   117

	SQAITransactionMode.DefSQFunction(engine, &AITransactionMode::Append,   "Append");

   118

	SQAITransactionMode.PostRegister(engine);

   119

}

   120

#endif /* SQUIRREL_CLASS */

   121

   122

#endif /* AI_TRANSACTIONMODE_HPP */