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) {

   114

			this->Exit();

   115

   116

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

   117

			assert(false);

   118

   119

			return;

   120

		}

   121

   122

		assert(this->state == RUNNING);

   123

	}

   124

   125

	/**

   126

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

   127

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

   128

	 */

   129

	void Resume()

   130

	{

   131

		/* Should be called from main fiber only */

   132

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

   133

		/* AI fiber should be suspended */

   134

		assert(this->state == SUSPENDED);

   135

   136

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

   137

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

   138

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

   139

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

   140

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

   141

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

   142

	}

   143

   144

	/**

   145

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

   146

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

   147

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

   148

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

   149

	 */

   150

	void RunTick()

   151

	{

   152

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

   154

   155

		/* Should be called from main fiber only */

   156

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

   157

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

   158

		assert(this != stFind(MAIN_FIBER));

   159

		/* AI fiber should be still suspended */

   160

		assert(this->state == SUSPENDED);

   161

   162

		this->controller->IncreaseTick();

   163

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

   173

		/* Make the fiber running again */

   174

		this->SwitchToState(RUNNING);

   175

	}

   176

   177

	/**

   178

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

   179

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

   180

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

   181

	 *  it won't be called anymore.

   182

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

   183

	 */

   184

	void Stop()

   185

	{

   186

		/* Should be called from main fiber only */

   187

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

   188

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

   190

   191

		/* Trigger a STOPPING round */

   192

		assert(this->state == SUSPENDED);

   193

		this->SwitchToState(STOPPING);

   195

   196

		/* Mark the fiber as STOPPED */

   197

		this->state = STOPPED;

   198

	}

   199

   200

	/**

   201

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

   202

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

   203

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

   204

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

   205

	 */

   206

	static AIFiber *stFind(int fiber_id)

   207

	{

   208

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

   209

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

   210

		if (fiber_id != MAIN_FIBER) return NULL;

   211

   212

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

   213

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

   214

	}

   215

   216

	/**

   217

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

   218

	 */

   219

	static void stRelease(int fiber_id)

   220

	{

   221

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

   222

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

   223

	}

   224

   225

	/**

   226

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

   227

	 */

   228

	static AIFiber *stCurrentFiber()

   229

	{

   230

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

   231

		assert(cur != NULL);

   232

		return cur;

   233

	}

   234

   235

private:

   236

	/**

   237

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

   238

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

   239

	 * @note Only call this from an other fiber.

   240

	 */

   241

	void SwitchToState(FiberState new_state)

   242

	{

   243

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

   244

		assert(stCurrentFiber() != this);

   245

		/* The fiber should be suspended */

   246

		assert(this->state == SUSPENDED);

   247

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

   248

		assert(this->fiber != NULL);

   249

   250

		/* Suspend the fiber */

   251

		stCurrentFiber()->state = SUSPENDED;

   252

   253

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

   254

		this->state = new_state;

   255

		this->fiber->SwitchToFiber();

   257

	}

   258

   259

	/**

   260

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

   261

	 */

   262

	void FiberProc()

   263

	{

   264

		/* We should be starting */

   265

		assert(this->state == STARTING);

   266

		/* We should be the active thread */

   267

		assert(stCurrentFiber() == this);

   268

   269

		/* Switch to running */

   270

		this->state = RUNNING;

   271

   272

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

   273

		AIFiber *main = stFind(MAIN_FIBER);

   274

		main->SwitchToState(RUNNING);

   275

   276

		if (this->state != STOPPING) {

   277

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

   278

			this->controller->Start();

   279

   280

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

   281

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

   282

   283

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

   284

			while (this->state != STOPPING) {

   285

				main->SwitchToState(RUNNING);

   286

			}

   287

		}

   288

   291

		this->Exit();

   292

   293

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

   294

		assert(false);

   295

	}

   296

   297

	/**

   298

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

   299

	 */

   300

	static void CDECL stFiberProc(void *fiber)

   301

	{

   302

		AIFiber *cur = (AIFiber *)fiber;

   303

		cur->FiberProc();

   304

	}

   305

   306

	/**

   307

	 * Exit a running fiber.

   308

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

   309

	 */

   310

	void Exit()

   311

	{

   312

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

   313

		assert(stCurrentFiber() == this);

   314

		/* We can never exit the main fiber */

   315

		assert(fiber_id != MAIN_FIBER);

   316

   317

		this->fiber->Exit();

   318

	}

   319

   320

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

   321

	static const int MAIN_FIBER = -1;

   322

   323

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

   324

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

   325

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

   326

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

   327

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

   328

};

   329

   330

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

   331

   332

/**

   333

 * Suspend the AI handler of a player.

   334

 * @param player the player to suspend for

   335

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

   336

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

   337

 */

   338

void AI_SuspendPlayer(PlayerID player, int timeout)

   339

{

   340

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

   341

	AIFiber *thr = AIFiber::stCurrentFiber();

   342

	assert(thr != NULL);

   343

	thr->Suspend(timeout);

   344

}

   345

   346

/**

   347

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

   348

 * @param player the player to run this tick for

   349

 */

   350

void AI_RunTick(PlayerID player)

   351

{

   352

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

   353

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

   354

	if (thr == NULL) {

   355

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

   356

		return;

   357

	}

   358

	thr->RunTick();

   359

}

   360

   361

/**

   362

 * Run an AI player for the first time.

   363

 * @param player     the (AI) player to start

   364

 * @param controller the actual AI

   365

 */

   366

void AI_StartPlayer(PlayerID player, AIController *controller)

   367

{

   368

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

   369

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

   370

	assert(thr == NULL);

   371

	thr = new AIFiber(player, controller);

   372

	thr->Start();

   373

}

   374

   375

/**

   376

 * Stops the given player

   377

 * @param player the (AI) player to stop

   378

 */

   379

void AI_StopPlayer(PlayerID player)

   380

{

   381

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

   382

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

   383

	if (thr == NULL) return;

   384

	thr->Stop();

   385

	AIFiber::stRelease(player);

   386

}

   387

   388

/**

   389

 * Callback for when a network command was executed.

   390

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

   391

 */

   392

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

   393

{

   394

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

   395

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

   396

	assert(thr != NULL);

   397

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

   398

	AIObject::SetLastCommandRes(success);

   399

   400

	/* Resume the fiber now */

   401

	thr->Resume();

   402

}

   403