1

/* $Id$ */

     2

     3

/** @file ai_transactionmode.cpp class to switch the AI to Transaction mode */

     4

     5

#include "ai_transactionmode.hpp"

     6

#include "ai_execmode.hpp"

     7

#include "../../command.h"

     8

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

     9

#include <stack>

    10

    11

bool AITransactionMode::ModeProc(TileIndex tile, uint32 p1, uint32 p2, uint procc, int32 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 += 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         = 0;

    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

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

    43

    44

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

    45

	AITransactionModeCommand command;

    46

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

    47

		command = this->command_stack.front();

    48

		free(command.text);

    49

		this->command_stack.pop();

    50

	}

    51

    52

	/* Clean up the reverse_stack too */

    53

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

    54

		command = this->reverse_stack.front();

    55

		free(command.text);

    56

		this->reverse_stack.pop();

    57

	}

    58

}

    59

    60

bool AITransactionMode::Execute()

    61

{

    62

	/* Make sure we are stopped */

    63

	this->Stop();

    64

    65

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

    66

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

    67

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

    68

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

    69

    70

	/* Switch to a forced execute mode */

    71

	AIExecMode exec;

    72

    73

	/* Reverse stack should be empty */

    74

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

    75

    76

	AITransactionModeCommand command;

    77

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

    78

		command = this->command_stack.front();

    79

		_cmd_text = command.text;

    80

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

    81

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

    82

		/* Add the command to the reverse stack */

    83

		this->reverse_stack.push(command);

    84

		/* Remove the item from the list */

    85

		this->command_stack.pop();

    86

	}

    87

    88

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

    89

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

    90

		command = this->reverse_stack.front();

    91

		free(command.text);

    92

		this->reverse_stack.pop();

    93

	}

    94

    95

	/* Reverse stack should be empty again */

    96

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

    97

    98

	return true;

    99

}

   100

   101

void AITransactionMode::Stop()

   102

{

   103

	this->stopped = true;

   104

}

   105

   106

void AITransactionMode::Rollback()

   107

{

   108

	AITransactionModeCommand command;

   109

   110

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

   111

	return;

   112

   113

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

   114

		command = this->reverse_stack.front();

   115

		_cmd_text = command.text;

   116

   117

		/* Find the reverse, and issue it */

   118

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

   119

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

   120

   121

		/* Remove the item from the list */

   122

		this->reverse_stack.pop();

   123

	}

   124

}

   125

   126

int32 AITransactionMode::GetCosts()

   127

{

   128

	return this->costs;

   129

}

   130

   131

void AITransactionMode::Append(AITransactionMode *transaction)

   132

{

   133

	/* Can't append to myself! */

   134

	if (transaction == this) return;

   135

   136

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

   137

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

   138

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

   139

		transaction->command_stack.pop();

   140

	}

   141

}