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 "../vehicle_func.h"

    12

#include "../player_func.h"

    13

#include "ai.h"

    14

#include "ai_threads.h"

    15

#include "api/ai_controller.hpp"

    16

#include "api/ai_object.hpp"

    17

#include <map>

    18

    19

class AIFiber : public SimpleCountedObject {

    20

private:

    21

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

    22

    23

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

    24

	enum FiberState {

    25

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

    26

		STARTING,    ///< The fiber is just started

    27

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

    28

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

    29

		STOPPING,    ///< We are being stopped

    30

		STOPPED,     ///< The main AI has stopped

    31

	};

    32

    33

public:

    34

	/**

    35

	 * Initialize this AIFiber for the given controller.

    36

	 * @param player The PlayerID of this AI.

    37

	 * @param controller The AI we have to run.

    38

	 */

    39

	AIFiber(PlayerID player, AIController *controller) :

    40

		fiber_id(player),

    41

		state(INITIALIZED),

    42

		ticks_to_sleep(0),

    43

		controller(controller),

    44

		fiber(NULL)

    45

	{

    46

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

    47

		assert(s_fibers[player] == NULL);

    48

		/* Register the new fiber */

    49

		s_fibers[player] = this;

    50

    51

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

    52

		if (player != MAIN_FIBER) {

    53

			stFind(MAIN_FIBER);

    54

		} else {

    55

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

    56

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

    57

		}

    58

	}

    59

    60

	~AIFiber()

    61

	{

    62

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

    63

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

    64

		/* Clean up */

    65

		delete this->fiber;

    66

	}

    67

    68

	/**

    69

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

    70

	 *  suspending command.

    71

	 */

    72

	bool Start()

    73

	{

    74

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

    75

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

    76

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

    77

		assert(this->fiber == NULL);

    78

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

    79

		assert(fiber_id != MAIN_FIBER);

    80

    81

		/* Create fiber for this AI */

    82

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

    83

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

    84

    85

		/* Switch to STARTING mode */

    86

		this->state = SUSPENDED;

    87

		this->SwitchToState(STARTING);

    88

    89

		return true;

    90

	}

    91

    92

	/**

    93

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

    94

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

    95

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

    96

	 */

    97

	void Suspend(int timeout)

    98

	{

    99

		/* Should not attempt to suspend main fiber */

   100

		assert(this->fiber_id != MAIN_FIBER);

   101

		/* AI fiber should be running */

   102

		assert(this->state == RUNNING);

   103

		/* We can only suspend ourself */

   104

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

   105

   106

		this->ticks_to_sleep = timeout;

   107

   108

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

   109

		AIFiber *main = stFind(MAIN_FIBER);

   110

		main->SwitchToState(RUNNING);

   111

   112

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

   113

		if (this->state == STOPPING) {

   114

			/* Suspend, and exit */

   115

			this->state = SUSPENDED;

   116

			this->Exit();

   117

   118

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

   119

			assert(false);

   120

   121

			return;

   122

		}

   123

   124

		assert(this->state == RUNNING);

   125

	}

   126

   127

	/**

   128

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

   129

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

   130

	 */

   131

	void Resume()

   132

	{

   133

		/* Should be called from main fiber only */

   134

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

   135

		/* AI fiber should be suspended */

   136

		assert(this->state == SUSPENDED);

   137

   138

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

   139

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

   140

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

   141

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

   142

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

   143

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

   144

	}

   145

   146

	/**

   147

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

   148

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

   149

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

   150

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

   151

	 */

   152

	void RunTick()

   153

	{

   154

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

   155

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

   156

   157

		/* Should be called from main fiber only */

   158

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

   159

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

   160

		assert(this != stFind(MAIN_FIBER));

   161

		/* AI fiber should be still suspended */

   162

		assert(this->state == SUSPENDED);

   163

   164

		this->controller->IncreaseTick();

   165

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

   175

		/* Make the fiber running again */

   176

		this->SwitchToState(RUNNING);

   177

	}

   178

   179

	/**

   180

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

   181

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

   182

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

   183

	 *  it won't be called anymore.

   184

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

   185

	 */

   186

	void Stop()

   187

	{

   188

		/* Should be called from main fiber only */

   189

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

   190

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

   191

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

   192

   193

		/* Trigger a STOPPING round */

   194

		assert(this->state == SUSPENDED);

   195

		this->SwitchToState(STOPPING);

   196

		assert(this->state == SUSPENDED);

   197

   198

		/* Mark the fiber as STOPPED */

   199

		this->state = STOPPED;

   200

	}

   201

   202

	/**

   203

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

   204

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

   205

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

   206

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

   207

	 */

   208

	static AIFiber *stFind(int fiber_id)

   209

	{

   210

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

   211

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

   212

		if (fiber_id != MAIN_FIBER) return NULL;

   213

   214

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

   215

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

   216

	}

   217

   218

	/**

   219

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

   220

	 */

   221

	static void stRelease(int fiber_id)

   222

	{

   223

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

   224

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

   225

	}

   226

   227

	/**

   228

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

   229

	 */

   230

	static AIFiber *stCurrentFiber()

   231

	{

   232

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

   233

		assert(cur != NULL);

   234

		return cur;

   235

	}

   236

   237

private:

   238

	/**

   239

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

   240

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

   241

	 * @note Only call this from an other fiber.

   242

	 */

   243

	void SwitchToState(FiberState new_state)

   244

	{

   245

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

   246

		assert(stCurrentFiber() != this);

   247

		/* The fiber should be suspended */

   248

		assert(this->state == SUSPENDED);

   249

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

   250

		assert(this->fiber != NULL);

   251

   252

		/* Suspend the fiber */

   253

		stCurrentFiber()->state = SUSPENDED;

   254

   255

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

   256

		this->state = new_state;

   257

		this->fiber->SwitchToFiber();

   258

		assert(this->state == SUSPENDED);

   259

	}

   260

   261

	/**

   262

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

   263

	 */

   264

	void FiberProc()

   265

	{

   266

		/* We should be starting */

   267

		assert(this->state == STARTING);

   268

		/* We should be the active thread */

   269

		assert(stCurrentFiber() == this);

   270

   271

		/* Switch to running */

   272

		this->state = RUNNING;

   273

   274

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

   275

		AIFiber *main = stFind(MAIN_FIBER);

   276

		main->SwitchToState(RUNNING);

   277

   281

   284

   289

		}

   290

   291

		/* Suspend, and exit */

   292

		this->state = SUSPENDED;

   293

		this->Exit();

   294

   295

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

   296

		assert(false);

   297

	}

   298

   299

	/**

   300

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

   301

	 */

   302

	static void CDECL stFiberProc(void *fiber)

   303

	{

   304

		AIFiber *cur = (AIFiber *)fiber;

   305

		cur->FiberProc();

   306

	}

   307

   308

	/**

   309

	 * Exit a running fiber.

   310

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

   311

	 */

   312

	void Exit()

   313

	{

   314

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

   315

		assert(stCurrentFiber() == this);

   316

		/* We can never exit the main fiber */

   317

		assert(fiber_id != MAIN_FIBER);

   318

   319

		this->fiber->Exit();

   320

	}

   321

   322

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

   323

	static const int MAIN_FIBER = -1;

   324

   325

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

   326

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

   327

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

   328

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

   329

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

   330

};

   331

   332

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

   333

   334

/**

   335

 * Suspend the AI handler of a player.

   336

 * @param player the player to suspend for

   337

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

   338

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

   339

 */

   340

void AI_SuspendPlayer(PlayerID player, int timeout)

   341

{

   342

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

   343

	AIFiber *thr = AIFiber::stCurrentFiber();

   344

	assert(thr != NULL);

   345

	thr->Suspend(timeout);

   346

}

   347

   348

/**

   349

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

   350

 * @param player the player to run this tick for

   351

 */

   352

void AI_RunTick(PlayerID player)

   353

{

   354

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

   355

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

   356

	if (thr == NULL) {

   357

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

   358

		return;

   359

	}

   360

	thr->RunTick();

   361

}

   362

   363

/**

   364

 * Run an AI player for the first time.

   365

 * @param player     the (AI) player to start

   366

 * @param controller the actual AI

   367

 */

   368

void AI_StartPlayer(PlayerID player, AIController *controller)

   369

{

   370

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

   371

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

   372

	assert(thr == NULL);

   373

	thr = new AIFiber(player, controller);

   374

	thr->Start();

   375

}

   376

   377

/**

   378

 * Stops the given player

   379

 * @param player the (AI) player to stop

   380

 */

   381

void AI_StopPlayer(PlayerID player)

   382

{

   383

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

   384

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

   385

	if (thr == NULL) return;

   386

	thr->Stop();

   387

	AIFiber::stRelease(player);

   388

}

   389

   390

/**

   391

 * Callback for when a network command was executed.

   392

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

   393

 */

   394

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

   395

{

   396

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

   397

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

   398

	assert(thr != NULL);

   399

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

   400

	AIObject::SetLastCommandRes(success);

   401

	/* Store some values inside the AIObject static memory */

   402

	AIObject::SetNewVehicleID(_new_vehicle_id);

   403

   404

	/* Resume the fiber now */

   405

	thr->Resume();

   406

}

   407