1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "npf.h"

     5

#include "aystar.h"

     6

#include "macros.h"

     7

#include "pathfind.h"

     8

#include "station.h"

     9

#include "tile.h"

    10

#include "depot.h"

    11

    12

AyStar _npf_aystar;

    13

    14

/* The cost of each trackdir. A diagonal piece is the full NPF_TILE_LENGTH,

    15

 * the shorter piece is sqrt(2)/2*NPF_TILE_LENGTH =~ 0.7071

    16

 */

    17

#define NPF_STRAIGHT_LENGTH (uint)(NPF_TILE_LENGTH * STRAIGHT_TRACK_LENGTH)

    18

static const uint _trackdir_length[TRACKDIR_END] = {

    19

	NPF_TILE_LENGTH, NPF_TILE_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH,

    20

	0, 0,

    21

	NPF_TILE_LENGTH, NPF_TILE_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH, NPF_STRAIGHT_LENGTH

    22

};

    23

    24

uint NTPHash(uint key1, uint key2)

    25

{

    26

	/* This function uses the old hash, which is fixed on 10 bits (1024 buckets) */

    27

	return PATHFIND_HASH_TILE(key1);

    28

}

    29

    30

/**

    31

 * Calculates a hash value for use in the NPF.

    32

 * @param key1	The TileIndex of the tile to hash

    33

 * @param key1	The Trackdir of the track on the tile.

    34

 *

    35

 * @todo	Think of a better hash.

    36

 */

    37

uint NPFHash(uint key1, uint key2)

    38

{

    39

	/* TODO: think of a better hash? */

    40

	uint part1 = TileX(key1) & NPF_HASH_HALFMASK;

    41

	uint part2 = TileY(key1) & NPF_HASH_HALFMASK;

    42

    43

	assert(IsValidTrackdir(key2));

    44

	assert(IsValidTile(key1));

    45

	return ((((part1 << NPF_HASH_HALFBITS) | part2)) + (NPF_HASH_SIZE * key2 / TRACKDIR_END)) % NPF_HASH_SIZE;

    46

}

    47

    48

int32 NPFCalcZero(AyStar* as, AyStarNode* current, OpenListNode* parent) {

    49

	return 0;

    50

}

    51

    52

/* Calcs the tile of given station that is closest to a given tile

    53

 * for this we assume the station is a rectangle,

    54

 * as defined by its top tile (st->train_tile) and its width/height (st->trainst_w, st->trainst_h)

    55

 */

    56

TileIndex CalcClosestStationTile(int station, TileIndex tile) {

    57

	const Station* st = GetStation(station);

    58

    59

	int x1,x2,x3,tx;

    60

	int y1,y2,y3,ty;

    61

    62

	x1 = TileX(st->train_tile);  y1 = TileY(st->train_tile);  // topmost corner of station

    63

	x2 = x1 + st->trainst_w - 1; y2 = y1 + st->trainst_h - 1; // lowermost corner of station

    64

	x3 = TileX(tile);            y3 = TileY(tile);            // tile we take the distance from

    65

    66

	// we are going the aim for the x coordinate of the closest corner

    67

	// but if we are between those coordinates, we will aim for our own x coordinate

    68

	if (x3 < x1)

    69

		tx = x1;

    70

	else if (x3 > x2)

    71

		tx = x2;

    72

	else

    73

		tx = x3;

    74

    75

	// same for y coordinate, see above comment

    76

	if (y3 < y1)

    77

		ty = y1;

    78

	else if (y3 > y2)

    79

		ty = y2;

    80

	else

    81

		ty = y3;

    82

    83

	// return the tile of our target coordinates

    84

	return TILE_XY(tx,ty);

    85

};

    86

    87

/* Calcs the heuristic to the target station or tile. For train stations, it

    88

 * takes into account the direction of approach.

    89

 */

    90

int32 NPFCalcStationOrTileHeuristic(AyStar* as, AyStarNode* current, OpenListNode* parent) {

    91

	NPFFindStationOrTileData* fstd = (NPFFindStationOrTileData*)as->user_target;

    92

	NPFFoundTargetData* ftd = (NPFFoundTargetData*)as->user_path;

    93

	TileIndex from = current->tile;

    94

	TileIndex to = fstd->dest_coords;

    95

	uint dist;

    96

    97

	// for train-stations, we are going to aim for the closest station tile

    98

	if ((as->user_data[NPF_TYPE] == TRANSPORT_RAIL) && (fstd->station_index != -1))

    99

		to = CalcClosestStationTile(fstd->station_index, from);

   100

   101

	if (as->user_data[NPF_TYPE] == TRANSPORT_ROAD)

   102

		/* Since roads only have diagonal pieces, we use manhattan distance here */

   103

		dist = DistanceManhattan(from, to) * NPF_TILE_LENGTH;

   104

	else

   105

		/* Ships and trains can also go diagonal, so the minimum distance is shorter */

   106

		dist = DistanceTrack(from, to) * NPF_TILE_LENGTH;

   107

   108

	if (dist < ftd->best_bird_dist) {

   109

		ftd->best_bird_dist = dist;

   110

		ftd->best_trackdir = current->user_data[NPF_TRACKDIR_CHOICE];

   111

	}

   112

	DEBUG(npf, 4)("Calculating H for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), dist);

   113

	return dist;

   114

}

   115

   116

   117

/* Fills AyStarNode.user_data[NPF_TRACKDIRCHOICE] with the chosen direction to

   118

 * get here, either getting it from the current choice or from the parent's

   119

 * choice */

   120

void NPFFillTrackdirChoice(AyStarNode* current, OpenListNode* parent)

   121

{

   122

	if (parent->path.parent == NULL) {

   123

		Trackdir trackdir = (Trackdir)current->direction;

   124

		/* This is a first order decision, so we'd better save the

   125

		 * direction we chose */

   126

		current->user_data[NPF_TRACKDIR_CHOICE] = trackdir;

   127

		DEBUG(npf, 6)("Saving trackdir: %#x", trackdir);

   128

	} else {

   129

		/* We've already made the decision, so just save our parent's

   130

		 * decision */

   131

		current->user_data[NPF_TRACKDIR_CHOICE] = parent->path.node.user_data[NPF_TRACKDIR_CHOICE];

   132

	}

   133

   134

}

   135

   136

/* Will return the cost of the tunnel. If it is an entry, it will return the

   137

 * cost of that tile. If the tile is an exit, it will return the tunnel length

   138

 * including the exit tile. Requires that this is a Tunnel tile */

   139

uint NPFTunnelCost(AyStarNode* current) {

   140

	DiagDirection exitdir = TrackdirToExitdir((Trackdir)current->direction);

   141

	TileIndex tile = current->tile;

   142

	if ( (DiagDirection)(_map5[tile] & 3) == ReverseDiagdir(exitdir)) {

   143

		/* We just popped out if this tunnel, since were

   144

		 * facing the tunnel exit */

   145

		FindLengthOfTunnelResult flotr;

   146

		flotr = FindLengthOfTunnel(tile, ReverseDiagdir(exitdir));

   147

		return flotr.length * NPF_TILE_LENGTH;

   148

		//TODO: Penalty for tunnels?

   149

	} else {

   150

		/* We are entering the tunnel, the enter tile is just a

   151

		 * straight track */

   152

		return NPF_TILE_LENGTH;

   153

	}

   154

}

   155

   156

uint NPFSlopeCost(AyStarNode* current) {

   157

	TileIndex next = current->tile + TileOffsByDir(TrackdirToExitdir(current->direction));

   158

	int x,y;

   159

	int8 z1,z2;

   160

   161

	x = TileX(current->tile) * TILE_SIZE;

   162

	y = TileY(current->tile) * TILE_SIZE;

   163

	/* get the height of the center of the current tile */

   164

	z1 = GetSlopeZ(x+TILE_HEIGHT, y+TILE_HEIGHT);

   165

   166

	x = TileX(next) * TILE_SIZE;

   167

	y = TileY(next) * TILE_SIZE;

   168

	/* get the height of the center of the next tile */

   169

	z2 = GetSlopeZ(x+TILE_HEIGHT, y+TILE_HEIGHT);

   170

   171

	if ((z2 - z1) > 1) {

   172

		/* Slope up */

   173

		return _patches.npf_rail_slope_penalty;

   174

	}

   175

	return 0;

   176

	/* Should we give a bonus for slope down? Probably not, we

   177

	 * could just substract that bonus from the penalty, because

   178

	 * there is only one level of steepness... */

   179

}

   180

   181

/* Mark tiles by mowing the grass when npf debug level >= 1 */

   182

void NPFMarkTile(TileIndex tile) {

   183

#ifdef NO_DEBUG_MESSAGES

   184

	return;

   185

#else

   186

	if (_debug_npf_level >= 1)

   187

		switch(GetTileType(tile)) {

   188

			case MP_RAILWAY:

   189

				/* DEBUG: mark visited tiles by mowing the grass under them

   190

				 * ;-) */

   191

				if (!IsTileDepotType(tile, TRANSPORT_RAIL)) {

   192

					_map2[tile] &= ~15; /* Clear bits 0-3 */

   193

					MarkTileDirtyByTile(tile);

   194

				}

   195

				break;

   196

			case MP_STREET:

   197

				if (!IsTileDepotType(tile, TRANSPORT_ROAD)) {

   198

					_map3_hi[tile] &= ~0x70; /* Clear bits 4-6 */

   199

					MarkTileDirtyByTile(tile);

   200

				}

   201

				break;

   202

			default:

   203

				break;

   204

		}

   205

#endif

   206

}

   207

   208

int32 NPFWaterPathCost(AyStar* as, AyStarNode* current, OpenListNode* parent) {

   209

	//TileIndex tile = current->tile;

   210

	int32 cost = 0;

   211

	Trackdir trackdir = (Trackdir)current->direction;

   212

   213

	cost = _trackdir_length[trackdir]; /* Should be different for diagonal tracks */

   214

   215

	if (IsBuoyTile(current->tile) && IsDiagonalTrackdir(trackdir))

   216

		cost += _patches.npf_buoy_penalty; /* A small penalty for going over buoys */

   217

   218

	if (current->direction != NextTrackdir((Trackdir)parent->path.node.direction))

   219

		cost += _patches.npf_water_curve_penalty;

   220

   221

	/* TODO More penalties? */

   222

   223

	return cost;

   224

}

   225

   226

/* Determine the cost of this node, for road tracks */

   227

int32 NPFRoadPathCost(AyStar* as, AyStarNode* current, OpenListNode* parent) {

   228

	TileIndex tile = current->tile;

   229

	int32 cost = 0;

   230

   231

	/* Determine base length */

   232

	switch (GetTileType(tile)) {

   233

		case MP_TUNNELBRIDGE:

   234

			if ((_map5[tile] & 0xF0)==0) {

   235

				cost = NPFTunnelCost(current);

   236

				break;

   237

			}

   238

			/* Fall through if above if is false, it is a bridge

   239

			 * then. We treat that as ordinary rail */

   240

		case MP_STREET:

   241

			cost = NPF_TILE_LENGTH;

   242

			break;

   243

		default:

   244

			break;

   245

	}

   246

   247

	/* Determine extra costs */

   248

   249

	/* Check for slope */

   250

	cost += NPFSlopeCost(current);

   251

   252

	/* Check for turns. Road vehicles only really drive diagonal, turns are

   253

	 * represented by non-diagonal tracks */

   254

	if (!IsDiagonalTrackdir(current->direction))

   255

		cost += _patches.npf_road_curve_penalty;

   256

   257

	NPFMarkTile(tile);

   258

	DEBUG(npf, 4)("Calculating G for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), cost);

   259

	return cost;

   260

}

   261

   262

   263

/* Determine the cost of this node, for railway tracks */

   264

int32 NPFRailPathCost(AyStar* as, AyStarNode* current, OpenListNode* parent) {

   265

	TileIndex tile = current->tile;

   266

	Trackdir trackdir = (Trackdir)current->direction;

   267

	int32 cost = 0;

   268

	/* HACK: We create a OpenListNode manualy, so we can call EndNodeCheck */

   269

	OpenListNode new_node;

   270

   271

	/* Determine base length */

   272

	switch (GetTileType(tile)) {

   273

		case MP_TUNNELBRIDGE:

   274

			if ((_map5[tile] & 0xF0)==0) {

   275

				cost = NPFTunnelCost(current);

   276

				break;

   277

			}

   278

			/* Fall through if above if is false, it is a bridge

   279

			 * then. We treat that as ordinary rail */

   280

		case MP_RAILWAY:

   281

			cost = _trackdir_length[trackdir]; /* Should be different for diagonal tracks */

   282

			break;

   283

		case MP_STREET: /* Railway crossing */

   284

			cost = NPF_TILE_LENGTH;

   285

			break;

   286

		case MP_STATION:

   287

			/* We give a station tile a penalty. Logically we would only

   288

					* want to give station tiles that are not our destination

   289

					* this penalty. This would discourage trains to drive through

   290

					* busy stations. But, we can just give any station tile a

   291

					* penalty, because every possible route will get this penalty

   292

					* exactly once, on its end tile (if it's a station) and it

   293

			* will therefore not make a difference. */

   294

			cost = NPF_TILE_LENGTH + _patches.npf_rail_station_penalty;

   295

			break;

   296

		default:

   297

			break;

   298

	}

   299

   300

	/* Determine extra costs */

   301

   302

	/* Check for signals */

   303

	if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir)) {

   304

		/* Ordinary track with signals */

   305

		if (GetSignalState(tile, trackdir) == SIGNAL_STATE_RED) {

   306

			/* Signal facing us is red */

   307

			if (!NPFGetFlag(current, NPF_FLAG_SEEN_SIGNAL)) {

   308

				/* Penalize the first signal we

   309

				 * encounter, if it is red */

   310

   311

				/* Is this a presignal exit or combo? */

   312

				SignalType sigtype = GetSignalType(tile, TrackdirToTrack(trackdir));

   313

				if (sigtype == SIGTYPE_EXIT || sigtype == SIGTYPE_COMBO)

   314

					/* Penalise exit and combo signals differently (heavier) */

   315

					cost += _patches.npf_rail_firstred_exit_penalty;

   316

				else

   317

					cost += _patches.npf_rail_firstred_penalty;

   318

			}

   319

			/* Record the state of this signal */

   320

			NPFSetFlag(current, NPF_FLAG_LAST_SIGNAL_RED, true);

   321

		} else {

   322

			/* Record the state of this signal */

   323

			NPFSetFlag(current, NPF_FLAG_LAST_SIGNAL_RED, false);

   324

		}

   325

		NPFSetFlag(current, NPF_FLAG_SEEN_SIGNAL, true);

   326

	}

   327

   328

	/* Penalise the tile if it is a target tile and the last signal was

   329

	 * red */

   330

	/* HACK: We create a new_node here so we can call EndNodeCheck. Ugly as hell

   331

	 * of course... */

   332

	new_node.path.node = *current;

   333

	if (as->EndNodeCheck(as, &new_node) == AYSTAR_FOUND_END_NODE && NPFGetFlag(current, NPF_FLAG_LAST_SIGNAL_RED))

   334

		cost += _patches.npf_rail_lastred_penalty;

   335

   336

	/* Check for slope */

   337

	cost += NPFSlopeCost(current);

   338

   339

	/* Check for turns */

   340

	if (current->direction != NextTrackdir((Trackdir)parent->path.node.direction))

   341

		cost += _patches.npf_rail_curve_penalty;

   342

	//TODO, with realistic acceleration, also the amount of straight track between

   343

	//      curves should be taken into account, as this affects the speed limit.

   344

   345

	/* Check for reverse in depot */

   346

	if (IsTileDepotType(tile, TRANSPORT_RAIL) && !as->EndNodeCheck(as, &new_node)==AYSTAR_FOUND_END_NODE)

   347

		/* Penalise any depot tile that is not the last tile in the path. This

   348

		 * _should_ penalise every occurence of reversing in a depot (and only

   349

		 * that) */

   350

		cost += _patches.npf_rail_depot_reverse_penalty;

   351

   352

	/* Check for occupied track */

   353

	//TODO

   354

   355

	NPFMarkTile(tile);

   356

	DEBUG(npf, 4)("Calculating G for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), cost);

   357

	return cost;

   358

}

   359

   360

/* Will find any depot */

   361

int32 NPFFindDepot(AyStar* as, OpenListNode *current) {

   362

	TileIndex tile = current->path.node.tile;

   363

   364

	/* It's not worth caching the result with NPF_FLAG_IS_TARGET here as below,

   365

	 * since checking the cache not that much faster than the actual check */

   366

	if (IsTileDepotType(tile, as->user_data[NPF_TYPE]))

   367

		return AYSTAR_FOUND_END_NODE;

   368

	else

   369

		return AYSTAR_DONE;

   370

}

   371

   372

/* Will find a station identified using the NPFFindStationOrTileData */

   373

int32 NPFFindStationOrTile(AyStar* as, OpenListNode *current) {

   374

	NPFFindStationOrTileData* fstd = (NPFFindStationOrTileData*)as->user_target;

   375

	AyStarNode *node = &current->path.node;

   376

	TileIndex tile = node->tile;

   377

   378

	/* If GetNeighbours said we could get here, we assume the station type

   379

	 * is correct */

   380

	if (

   381

		(fstd->station_index == -1 && tile == fstd->dest_coords) || /* We've found the tile, or */

   382

		(IsTileType(tile, MP_STATION) && _map2[tile] == fstd->station_index) /* the station */

   383

	) {

   384

		return AYSTAR_FOUND_END_NODE;

   385

	} else {

   386

		return AYSTAR_DONE;

   387

	}

   388

}

   389

   390

/* To be called when current contains the (shortest route to) the target node.

   391

 * Will fill the contents of the NPFFoundTargetData using

   392

 * AyStarNode[NPF_TRACKDIR_CHOICE].

   393

 */

   394

void NPFSaveTargetData(AyStar* as, OpenListNode* current) {

   395

	NPFFoundTargetData* ftd = (NPFFoundTargetData*)as->user_path;

   396

	ftd->best_trackdir = (Trackdir)current->path.node.user_data[NPF_TRACKDIR_CHOICE];

   397

	ftd->best_path_dist = current->g;

   398

	ftd->best_bird_dist = 0;

   399

	ftd->node = current->path.node;

   400

}

   401

   402

/**

   403

 * Finds out if a given player's vehicles are allowed to enter a given tile.

   404

 * @param owner    The owner of the vehicle.

   405

 * @param tile     The tile that is about to be entered.

   406

 * @param enterdir The direction from which the vehicle wants to enter the tile.

   407

 * @return         true if the vehicle can enter the tile.

   408

 * @todo           This function should be used in other places than just NPF,

   409

 *                 maybe moved to another file too.

   410

 */

   411

bool VehicleMayEnterTile(Owner owner, TileIndex tile, DiagDirection enterdir)

   412

{

   413

	if (

   414

		IsTileType(tile, MP_RAILWAY) /* Rail tile (also rail depot) */

   415

		|| IsTrainStationTile(tile) /* Rail station tile */

   416

		|| IsTileDepotType(tile, TRANSPORT_ROAD) /* Road depot tile */

   417

		|| IsRoadStationTile(tile) /* Road station tile */

   418

		|| IsTileDepotType(tile, TRANSPORT_WATER) /* Water depot tile */

   419

		)

   420

		return IsTileOwner(tile, owner); /* You need to own these tiles entirely to use them */

   421

   422

	switch (GetTileType(tile)) {

   423

		case MP_STREET:

   424

			/* rail-road crossing : are we looking at the railway part? */

   425

			if (IsLevelCrossing(tile) && GetCrossingTransportType(tile, TrackdirToTrack(DiagdirToDiagTrackdir(enterdir))) == TRANSPORT_RAIL)

   426

				return IsTileOwner(tile, owner); /* Railway needs owner check, while the street is public */

   427

			break;

   428

		case MP_TUNNELBRIDGE:

   429

#if 0

   430

/* OPTIMISATION: If we are on the middle of a bridge, we will not do the cpu

   431

 * intensive owner check, instead we will just assume that if the vehicle

   432

 * managed to get on the bridge, it is probably allowed to :-)

   433

 */

   434

			if ((_map5[tile] & 0xC6) == 0xC0 && (unsigned)(_map5[tile] & 0x1) == (enterdir & 0x1)) {

   435

				/* on the middle part of a railway bridge: find bridge ending */

   436

				while (IsTileType(tile, MP_TUNNELBRIDGE) && !((_map5[tile] & 0xC6) == 0x80)) {

   437

					tile += TileOffsByDir(_map5[tile] & 0x1);

   438

				}

   439

			}

   440

			/* if we were on a railway middle part, we are now at a railway bridge ending */

   441

#endif

   442

			if (

   443

				(_map5[tile] & 0xFC) == 0 /* railway tunnel */

   444

				|| (_map5[tile] & 0xC6) == 0x80 /* railway bridge ending */

   445

				|| ((_map5[tile] & 0xF8) == 0xE0 && ((unsigned)_map5[tile] & 0x1) != (enterdir & 0x1)) /* railway under bridge */

   446

				)

   447

				return IsTileOwner(tile, owner);

   448

			break;

   449

		default:

   450

			break;

   451

	}

   452

   453

	return true; /* no need to check */

   454

}

   455

   456

/* Will just follow the results of GetTileTrackStatus concerning where we can

   457

 * go and where not. Uses AyStar.user_data[NPF_TYPE] as the transport type and

   458

 * an argument to GetTileTrackStatus. Will skip tunnels, meaning that the

   459

 * entry and exit are neighbours. Will fill

   460

 * AyStarNode.user_data[NPF_TRACKDIR_CHOICE] with an appropriate value, and

   461

 * copy AyStarNode.user_data[NPF_NODE_FLAGS] from the parent */

   462

void NPFFollowTrack(AyStar* aystar, OpenListNode* current) {

   463

	Trackdir src_trackdir = (Trackdir)current->path.node.direction;

   464

	TileIndex src_tile = current->path.node.tile;

   465

	DiagDirection src_exitdir = TrackdirToExitdir(src_trackdir);

   466

	FindLengthOfTunnelResult flotr;

   467

	TileIndex dst_tile;

   468

	int i;

   469

	TrackdirBits trackdirbits, ts;

   470

	TransportType type = aystar->user_data[NPF_TYPE];

   471

	/* Initialize to 0, so we can jump out (return) somewhere an have no neighbours */

   472

	aystar->num_neighbours = 0;

   473

	DEBUG(npf, 4)("Expanding: (%d, %d, %d) [%d]", TileX(src_tile), TileY(src_tile), src_trackdir, src_tile);

   474

   475

	/* Find dest tile */

   476

	if (IsTileType(src_tile, MP_TUNNELBRIDGE) && (_map5[src_tile] & 0xF0)==0 && (DiagDirection)(_map5[src_tile] & 3) == src_exitdir) {

   477

		/* This is a tunnel. We know this tunnel is our type,

   478

		 * otherwise we wouldn't have got here. It is also facing us,

   479

		 * so we should skip it's body */

   480

		flotr = FindLengthOfTunnel(src_tile, src_exitdir);

   481

		dst_tile = flotr.tile;

   482

	} else {

   483

		if (type != TRANSPORT_WATER && (IsRoadStationTile(src_tile) || IsTileDepotType(src_tile, type))){

   484

			/* This is a road station or a train or road depot. We can enter and exit

   485

			 * those from one side only. Trackdirs don't support that (yet), so we'll

   486

			 * do this here. */

   487

   488

			DiagDirection exitdir;

   489

			/* Find out the exit direction first */

   490

			if (IsRoadStationTile(src_tile))

   491

				exitdir = GetRoadStationDir(src_tile);

   492

			else /* Train or road depot. Direction is stored the same for both, in map5 */

   493

				exitdir = GetDepotDirection(src_tile, type);

   494

   495

			/* Let's see if were headed the right way into the depot, and reverse

   496

			 * otherwise (only for trains, since only with trains you can

   497

			 * (sometimes) reach tiles after reversing that you couldn't reach

   498

			 * without reversing. */

   499

			if (src_trackdir == DiagdirToDiagTrackdir(ReverseDiagdir(exitdir)) && type == TRANSPORT_RAIL)

   500

				/* We are headed inwards. We can only reverse here, so we'll not