1

/* $Id$ */

     2

     3

/** @file ai_threads.cpp handles the threading of AIs */

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h"

     7

#include "../variables.h"

     8

#include "../debug.h"

     9

#include "../thread.h"

    10

#include "../fiber.hpp"

    11

#include "../player_func.h"

    12

#include "ai.h"

    13

#include "ai_threads.h"

    14

#include "api/ai_controller.hpp"

    15

#include "api/ai_object.hpp"

    16

#include <map>

    17

    18

class AIFiber : public SimpleCountedObject {

    19

private:

    20

	typedef std::map<int, CCountedPtr<AIFiber> > Fibers;

    21

    22

	/** Different states of the AI fiber. */

    23

	enum FiberState {

    24

		INITIALIZED, ///< The mutex and conditions are initialized

    25

		STARTING,    ///< The fiber is just started

    26

		RUNNING,     ///< We are inside the main AI

    27

		SUSPENDED,   ///< We are suspended (either by sleep or block)

    28

		STOPPING,    ///< We are being stopped

    29

		STOPPED,     ///< The main AI has stopped

    30

	};

    31

    32

public:

    33

	/**

    34

	 * Initialize this AIFiber for the given controller.

    35

	 * @param player The PlayerID of this AI.

    36

	 * @param controller The AI we have to run.

    37

	 */

    38

	AIFiber(PlayerID player, AIController *controller) :

    39

		fiber_id(player),

    40

		state(INITIALIZED),

    41

		ticks_to_sleep(0),

    42

		controller(controller),

    43

		fiber(NULL)

    44

	{

    45

		/* The player shouldn't have a fiber yet */

    46

		assert(s_fibers[player] == NULL);

    47

		/* Register the new fiber */

    48

		s_fibers[player] = this;

    49

    50

		/* Ensure that main fiber has its wrapper too */

    51

		if (player != MAIN_FIBER) {

    52

			stFind(MAIN_FIBER);

    53

		} else {

    54

			this->fiber = Fiber::AttachCurrent(this);

    55

			assert(this->fiber->IsRunning());

    56

		}

    57

	}

    58

    59

	~AIFiber()

    60

	{

    61

		/* Make sure we are not in the active list anymore */

    62

		assert(this->fiber_id == MAIN_FIBER || stFind(this->fiber_id) == NULL);

    63

		/* Clean up */

    64

		delete this->fiber;

    65

	}

    66

    67

	/**

    68

	 * Start the AI fiber and return once the AI calls Sleep or any other

    69

	 *  suspending command.

    70

	 */

    71

	bool Start()

    72

	{

    73

		/* Make sure we start fibers from the main fiber */

    74

		assert(stCurrentFiber() == stFind(MAIN_FIBER));

    75

		/* We shouldn't have a fiber yet */

    76

		assert(this->fiber == NULL);

    77

		/* And we shouldn't be starting the main fiber */

    78

		assert(fiber_id != MAIN_FIBER);

    79

    80

		/* Create fiber for this AI */

    81

		this->fiber = Fiber::New(&stFiberProc, this);

    82

		if (!this->fiber->IsRunning()) return false;

    83

    84

		/* Switch to STARTING mode */

    85

		this->state = SUSPENDED;

    86

		this->SwitchToState(STARTING);

    87

    88

		return true;

    89

	}

    90

    91

	/**

    92

	 * Suspend this AI for a 'timeout' of period.

    93

	 * @param timeout Time to suspend. < 0 means infinite (MultiPlayer only!)

    94

	 * @note Only call this from within the fiber you want to execute the function on.

    95

	 */

    96

	void Suspend(int timeout)

    97

	{

    98

		/* Should not attempt to suspend main fiber */

    99

		assert(this->fiber_id != MAIN_FIBER);

   100

		/* AI fiber should be running */

   101

		assert(this->state == RUNNING);

   102

		/* We can only suspend ourself */

   103

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

   104

   105

		this->ticks_to_sleep = timeout;

   106

   107

		/* When AI fiber gets suspended, it always switches back to main fiber */

   108

		AIFiber *main = stFind(MAIN_FIBER);

   109

		main->SwitchToState(RUNNING);

   110

   111

		/* The main fiber wants this AI to die */

   112

		if (this->state == STOPPING) {

   113

			/* Suspend, and exit */

   114

			this->state = SUSPENDED;

   115

			this->Exit();

   116

   117

			/* Here we will never come as... the fiber is dead */

   118

			assert(false);

   119

   120

			return;

   121

		}

   122

   123

		assert(this->state == RUNNING);

   124

	}

   125

   126

	/**

   127

	 * Set the AI fiber to resume at the next call of RunTick.

   128

	 * @note Only call this from within the main fiber.

   129

	 */

   130

	void Resume()

   131

	{

   132

		/* Should be called from main fiber only */

   133

		assert(stCurrentFiber() == stFind(MAIN_FIBER));

   134

		/* AI fiber should be suspended */

   135

		assert(this->state == SUSPENDED);

   136

   137

		/* Normally the ticks_to_sleep hangs at -1 for MP. Possible the MP is

   138

		 * faster then the delay requested by the user. In this case the value

   139

		 * is lower. To let the normal delay system kick in, we reverse the value

   140

		 * of ticks_to_sleep. But now it doesn't directly continue when the value

   141

		 * was 'hanging', so we subtract 1 and it all works fine. */

   142

		this->ticks_to_sleep = -this->ticks_to_sleep - 1;

   143

	}

   144

   145

	/**

   146

	 * Let the AI fiber run for a while and return when it is done.

   147

	 *  However, when the fiber is suspended and the suspend timeout has not yet

   148

	 *  passed, nothing happens except decrementing the before mentioned timeout.

   149

	 * @note Only call this from within the main fiber.

   150

	 */

   151

	void RunTick()

   152

	{

   153

		/* If we already stopped, don't do anything */

   154

		if (this->state == STOPPED) return;

   155

   156

		/* Should be called from main fiber only */

   157

		assert(stCurrentFiber() == stFind(MAIN_FIBER));

   158

		/* Only AI fibers should be resumed this way */

   159

		assert(this != stFind(MAIN_FIBER));

   160

		/* AI fiber should be still suspended */

   161

		assert(this->state == SUSPENDED);

   162

   163

		this->controller->IncreaseTick();

   164

   165

		/* If the value is < -1, the user wants a delay which might exceed the delay

   166

		 *  of the MP. Therefor we keep adding value to ticks_to_sleep till it

   167

		 *  reaches -1, and we 'hang' it there infinitely, until the MP commands

   168

		 *  comes in. In the case it happens sooner, the Resume() codes handles it

   169

		 *  nicely and makes the value positive with the remaining ticks to wait. */

   170

		if (this->ticks_to_sleep < -1)  this->ticks_to_sleep++;

   171

		if (this->ticks_to_sleep < 0)   return; // We have to wait infinitely

   172

		if (--this->ticks_to_sleep > 0) return; // We have to wait a little longer

   173

   174

		/* Make the fiber running again */

   175

		this->SwitchToState(RUNNING);

   176

	}

   177

   178

	/**

   179

	 * Try to stop the AI, and mark it as such. You can cleanup the AI after

   180

	 *  this if you like; it won't be become active for sure.

   181

	 * @note There is no guarantee the fiber dies or anything, we just promise

   182

	 *  it won't be called anymore.

   183

	 * @note Only call this from within the main fiber.

   184

	 */

   185

	void Stop()

   186

	{

   187

		/* Should be called from main fiber only */

   188

		assert(stCurrentFiber() == stFind(MAIN_FIBER));

   189

		/* If we already stopped, don't do anything */

   190

		if (this->state == STOPPED) return;

   191

   192

		/* Trigger a STOPPING round */

   193

		assert(this->state == SUSPENDED);

   194

		this->SwitchToState(STOPPING);

   195

		assert(this->state == SUSPENDED);

   196

   197

		/* Mark the fiber as STOPPED */

   198

		this->state = STOPPED;

   199

	}

   200

   201

	/**

   202

	 * Find and return the fiber object by its 'id' (player_id or MAIN_FIBER).

   203

	 *  Returns NULL if such fiber object doesn't exist. If

   204

	 *  (fiber_id == MAIN_FIBER) and the fiber object with this id doesn't

   205

	 *  exist, the new one is created and attached to the current (main) fiber.

   206

	 */

   207

	static AIFiber *stFind(int fiber_id)

   208

	{

   209

		Fibers::iterator it = s_fibers.find(fiber_id);

   210

		if (it != s_fibers.end()) return (*it).second;

   211

		if (fiber_id != MAIN_FIBER) return NULL;

   212

   213

		/* Main fiber doesn't have its own fiber object, create it */

   214

		return new AIFiber((PlayerID)MAIN_FIBER, NULL);

   215

	}

   216

   217

	/**

   218

	 * Remove fiber object from the collection by its 'id' and destroy it.

   219

	 */

   220

	static void stRelease(int fiber_id)

   221

	{

   222

		Fibers::iterator it = s_fibers.find(fiber_id);

   223

		if (it != s_fibers.end()) s_fibers.erase(it);

   224

	}

   225

   226

	/**

   227

	 * Find the fiber object that belongs to the currently running fiber (caller).

   228

	 */

   229

	static AIFiber *stCurrentFiber()

   230

	{

   231

		AIFiber *cur = (AIFiber *)Fiber::GetCurrentFiberData();

   232

		assert(cur != NULL);

   233

		return cur;

   234

	}

   235

   236

private:

   237

	/**

   238

	 * Switch the state of a fiber. It becomes active and executed until it

   239

	 *  changes the state. The current active fiber becomes SUSPENDED.

   240

	 * @note Only call this from an other fiber.

   241

	 */

   242

	void SwitchToState(FiberState new_state)

   243

	{

   244

		/* You can't switch the state of an already active fiber */

   245

		assert(stCurrentFiber() != this);

   246

		/* The fiber should be suspended */

   247

		assert(this->state == SUSPENDED);

   248

		/* And there should be an active fiber on it */

   249

		assert(this->fiber != NULL);

   250

   251

		/* Suspend the fiber */

   252

		stCurrentFiber()->state = SUSPENDED;

   253

   254

		/* Switch to new state, activate fiber, and check if we are suspended again */

   255

		this->state = new_state;

   256

		this->fiber->SwitchToFiber();

   257

		assert(this->state == SUSPENDED);

   258

	}

   259

   260

	/**

   261

	 * The method that runs in the new Fiber. Automaticly called when the Fiber becomes active.

   262

	 */

   263

	void FiberProc()

   264

	{

   265

		/* We should be starting */

   266

		assert(this->state == STARTING);

   267

		/* We should be the active thread */

   268

		assert(stCurrentFiber() == this);

   269

   270

		/* Switch to running */

   271

		this->state = RUNNING;

   272

   273

		/* We want to skip the first tick, so switch back to the main fiber */

   274

		AIFiber *main = stFind(MAIN_FIBER);

   275

		main->SwitchToState(RUNNING);

   276

   277

		if (this->state != STOPPING) {

   278

			/* Start up the AI (this should be an infinite loop) */

   279

			this->controller->Start();

   280

   281

			/* If we come here, the AI exited because it wanted to */

   282

			DEBUG(ai, 1, "We've got a suicidal AI for player %d", this->fiber_id);

   283

   284

			/* Wait until we are killed nicely by the game */

   285

			while (this->state != STOPPING) {

   286

				main->SwitchToState(RUNNING);

   287

			}

   288

		}

   289

   290

		/* Suspend, and exit */

   291

		this->state = SUSPENDED;

   292

		this->Exit();

   293

   294

		/* Here we will never come as... the fiber is dead */

   295

		assert(false);

   296

	}

   297

   298

	/**

   299

	 * Function that is started as process of the new AI fiber.

   300

	 */

   301

	static void CDECL stFiberProc(void *fiber)

   302

	{

   303

		AIFiber *cur = (AIFiber *)fiber;

   304

		cur->FiberProc();

   305

	}

   306

   307

	/**

   308

	 * Exit a running fiber.

   309

	 * @note Only call this from within the fiber you want to execute the function on.

   310

	 */

   311

	void Exit()

   312

	{

   313

		/* We can only exit if we are the thread */

   314

		assert(stCurrentFiber() == this);

   315

		/* We can never exit the main fiber */

   316

		assert(fiber_id != MAIN_FIBER);

   317

   318

		this->fiber->Exit();

   319

	}

   320

   321

	static Fibers s_fibers;          ///< Collection of active fibers.

   322

	static const int MAIN_FIBER = -1;

   323

   324

	int            fiber_id;         ///< id of this fiber (or MAIN_FIBER for the main).

   325

	FiberState     state;            ///< The current state of the AI.

   326

	int            ticks_to_sleep;   ///< Sleep this many runticks.

   327

	AIController   *controller;      ///< Controller of this AI.

   328

	Fiber          *fiber;           ///< Fiber we are connected to.

   329

};

   330

   331

/* static */ AIFiber::Fibers AIFiber::s_fibers;

   332

   333

/**

   334

 * Suspend the AI handler of a player.

   335

 * @param player the player to suspend for

   336

 * @param timeout Time to suspend. < 0 means infinite (MultiPlayer only!)

   337

 * @note This should be called from within the fiber running this player!

   338

 */

   339

void AI_SuspendPlayer(PlayerID player, int timeout)

   340

{

   341

	DEBUG(ai, 6, "AI_SuspendPlayer(%d, %d) from thr %d", player, timeout, ThreadObject::CurrentId());

   342

	AIFiber *thr = AIFiber::stCurrentFiber();

   343

	assert(thr != NULL);

   344

	thr->Suspend(timeout);

   345

}

   346

   347

/**

   348

 * Run the fiber of an AI player. Return when it is suspended again.

   349

 * @param player the player to run this tick for

   350

 */

   351

void AI_RunTick(PlayerID player)

   352

{

   353

	DEBUG(ai, 6, "AI_RunTick(%d) from thr %d", player, ThreadObject::CurrentId());

   354

	AIFiber *thr = AIFiber::stFind(player);

   355

	if (thr == NULL) {

   356

		DEBUG(ai, 0, "AI_RunTick() called for dead AI player #%d", player);

   357

		return;

   358

	}

   359

	thr->RunTick();

   360

}

   361

   362

/**

   363

 * Run an AI player for the first time.

   364

 * @param player     the (AI) player to start

   365

 * @param controller the actual AI

   366

 */

   367

void AI_StartPlayer(PlayerID player, AIController *controller)

   368

{

   369

	DEBUG(ai, 6, "AI_StartPlayer(%d) from thr %d", player, ThreadObject::CurrentId());

   370

	AIFiber *thr = AIFiber::stFind(player);

   371

	assert(thr == NULL);

   372

	thr = new AIFiber(player, controller);

   373

	thr->Start();

   374

}

   375

   376

/**

   377

 * Stops the given player

   378

 * @param player the (AI) player to stop

   379

 */

   380

void AI_StopPlayer(PlayerID player)

   381

{

   382

	DEBUG(ai, 6, "AI_StopPlayer(%d) from thr %d", player, ThreadObject::CurrentId());

   383

	AIFiber *thr = AIFiber::stFind(player);

   384

	if (thr == NULL) return;

   385

	thr->Stop();

   386

	AIFiber::stRelease(player);

   387

}

   388

   389

/**

   390

 * Callback for when a network command was executed.

   391

 *  As commands are always ordered, we don't have to worry about right command.

   392

 */

   393

void CcAI(bool success, TileIndex tile, uint32 p1, uint32 p2)

   394

{

   395

	DEBUG(ai, 6, "CcAI(%d) from thr %d", _current_player, ThreadObject::CurrentId());

   396

	AIFiber *thr = AIFiber::stFind(_current_player);

   397

	assert(thr != NULL);

   398

	/* Store if we were a success or not */

   399

	AIObject::SetLastCommandRes(success);

   400

   401

	/* Resume the fiber now */

   402

	thr->Resume();

   403

}

   404