1

/* $Id$ */

     2

     3

/** @file ai_transactionmode.cpp Implementation of AITransactionMode. */

     4

     5

#include "ai_transactionmode.hpp"

     6

#include "ai_execmode.hpp"

     7

#include "../../command_func.h"

     8

#include "../../debug.h"

     9

#include <stack>

    10

    11

bool AITransactionMode::ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, CommandCost costs)

    12

{

    13

	AITransactionMode *instance = (AITransactionMode *)AIObject::GetDoCommandModeInstance();

    14

	/* Don't record if we are stopped */

    15

	if (instance->stopped) return false;

    16

	AITransactionModeCommand command;

    17

    18

	/* Store all params in a nice list, so we can execute them later */

    19

	command.tile  = tile;

    20

	command.p1    = p1;

    21

	command.p2    = p2;

    22

	command.procc = procc;

    23

	command.text  = (_cmd_text == NULL) ? NULL : strdup(_cmd_text);

    24

	instance->command_stack.push(command);

    25

	instance->costs.AddCost(costs);

    26

    27

	/* Now we return 'false', as we don't want to execute the commands just yet */

    28

	return false;

    29

}

    30

    31

AITransactionMode::AITransactionMode()

    32

{

    33

	this->costs         = CommandCost();

    34

	this->stopped       = false;

    35

	this->last_mode     = this->GetDoCommandMode();

    36

	this->last_instance = this->GetDoCommandModeInstance();

    37

	this->SetDoCommandMode(&AITransactionMode::ModeProc, this);

    38

}

    39

    40

AITransactionMode::~AITransactionMode()

    41

{

    42

	assert(this->GetDoCommandModeInstance() == this);

    43

	this->SetDoCommandMode(this->last_mode, this->last_instance);

    44

    45

	/* Clean up the command_stack nicely (as in: free the cmd_text) */

    46

	AITransactionModeCommand command;

    47

	while (!this->command_stack.empty()) {

    48

		command = this->command_stack.front();

    49

		free(command.text);

    50

		this->command_stack.pop();

    51

	}

    52

    53

	/* Clean up the reverse_stack too */

    54

	while (!this->reverse_stack.empty()) {

    55

		command = this->reverse_stack.front();

    56

		free(command.text);

    57

		this->reverse_stack.pop();

    58

	}

    59

}

    60

    61

bool AITransactionMode::Execute()

    62

{

    63

	/* Make sure we are stopped */

    64

	this->Stop();

    65

    66

	/* Remove the costs this transaction costs from the total costs, so any

    67

	 *  'accounting' running on the background will get the real costs for

    68

	 *  executing, and not the double value of both testing and executing */

    69

	this->IncreaseDoCommandCosts(-this->GetCosts());

    70

    71

	/* Switch to a forced execute mode */

    72

	AIExecMode exec;

    73

    74

	/* Reverse stack should be empty */

    75

	assert(this->reverse_stack.empty());

    76

    77

	AITransactionModeCommand command;

    78

	while (!this->command_stack.empty()) {

    79

		command = this->command_stack.front();

    80

		_cmd_text = command.text;

    81

		/* Make sure we return 'false' if the command fails to execute. This allows rollback of failed builds. */

    82

		if (!this->DoCommand(command.tile, command.p1, command.p2, command.procc)) return false;

    83

		/* Add the command to the reverse stack */

    84

		this->reverse_stack.push(command);

    85

		/* Remove the item from the list */

    86

		this->command_stack.pop();

    87

	}

    88

    89

	/* Everything went okay, clean the reverse stack */

    90

	while (!this->reverse_stack.empty()) {

    91

		command = this->reverse_stack.front();

    92

		free(command.text);

    93

		this->reverse_stack.pop();

    94

	}

    95

    96

	/* Reverse stack should be empty again */

    97

	assert(this->reverse_stack.empty());

    98

    99

	return true;

   100

}

   101

   102

void AITransactionMode::Stop()

   103

{

   104

	this->stopped = true;

   105

}

   106

   107

void AITransactionMode::Rollback()

   108

{

   109

	AITransactionModeCommand command;

   110

   111

	DEBUG(ai, 0, "AITransactionMode::Rollback is not yet implemented");

   112

	return;

   113

   114

	while (!this->reverse_stack.empty()) {

   115

		command = this->reverse_stack.front();

   116

		_cmd_text = command.text;

   117

   118

		/* Find the reverse, and issue it */

   119

		/* TODO -- Make a table which reverses every command.procc */

   120

		this->DoCommand(command.tile, command.p1, command.p2, command.procc);

   121

   122

		/* Remove the item from the list */

   123

		this->reverse_stack.pop();

   124

	}

   125

}

   126

   127

Money AITransactionMode::GetCosts()

   128

{

   129

	return this->costs.GetCost();

   130

}

   131

   132

void AITransactionMode::Append(AITransactionMode *transaction)

   133

{

   134

	/* Can't append to myself! */

   135

	if (transaction == this) return;

   136

   137

	/* Simply move the queue from transaction to ourself */

   138

	while (!transaction->command_stack.empty()) {

   139

		this->command_stack.push(transaction->command_stack.front());

   140

		transaction->command_stack.pop();

   141

	}

   142

}