1

/* $Id$ */

     2

     3

/** @file ai_transactionmode.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

	CommandCost 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, CommandCost costs);

    45

    46

public:

    47

	/**

    48

	 * The name of the class, needed by several sub-processes.

    49

	 */

    50

	static const char *GetClassName() { return "AITransactionMode"; }

    51

    52

	/**

    53

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

    54

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

    55

	 *   current when the instance was created!

    56

	 */

    57

	AITransactionMode();

    58

    59

	/**

    60

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

    61

	 *   in when the instance was created.

    62

	 */

    63

	~AITransactionMode();

    64

    65

	/**

    66

	 * Execute all recorded commands.

    67

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

    68

	 *   commands that follow won't be executed either.

    69

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

    70

	 *   Stop() yourself).

    71

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

    72

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

    73

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

    74

	 */

    75

	bool Execute();

    76

    77

	/**

    78

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

    79

	 *   instance was destroyed.

    80

	 */

    81

	void Stop();

    82

    83

	/**

    84

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

    85

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

    86

	 *   back, so this command will do nothing.

    87

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

    88

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

    89

	 *   In that case the problem will be silently ignored.

    90

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

    91

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

    92

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

    93

	 */

    94

	void Rollback();

    95

    96

	/**

    97

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

    98

	 *   numbers can always differ).

    99

	 */

   100

	Money GetCosts();

   101

   102

	/**

   103

	 * Append one transaction list to an other.

   104

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

   105

	 */

   106

	void Append(AITransactionMode *transaction);

   107

};

   108

   109

#endif /* AI_TRANSACTIONMODE_HPP */