1 /* $Id$ */

     2 

     3 #include "stdafx.h"

     4 #include "openttd.h"

     5 #include "debug.h"

     6 #include "functions.h"

     7 #include "gui.h"

     8 #include "spritecache.h"

     9 #include "strings.h"

    10 #include "table/sprites.h"

    11 #include "table/strings.h"

    12 #include "map.h"

    13 #include "viewport.h"

    14 #include "window.h"

    15 #include "vehicle.h"

    16 #include "station.h"

    17 #include "gfx.h"

    18 #include "town.h"

    19 #include "signs.h"

    20 #include "waypoint.h"

    21 #include "variables.h"

    22 #include "train.h"

    23 

    24 #define VIEWPORT_DRAW_MEM (65536 * 2)

    25 

    26 /* viewport.c */

    27 // XXX - maximum viewports is maximum windows - 2 (main toolbar + status bar)

    28 static ViewPort _viewports[25 - 2];

    29 static uint32 _active_viewports;    ///< bitmasked variable where each bit signifies if a viewport is in use or not

    30 assert_compile(lengthof(_viewports) < sizeof(_active_viewports) * 8);

    31 

    32 static bool _added_tile_sprite;

    33 static bool _offset_ground_sprites;

    34 

    35 /* The in-game coordiante system looks like this *

    36  *                                               *

    37  *                    ^ Z                        *

    38  *                    |                          *

    39  *                    |                          *

    40  *                    |                          *

    41  *                    |                          *

    42  *                 /     \                       *

    43  *              /           \                    *

    44  *           /                 \                 *

    45  *        /                       \              *

    46  *   X <                             > Y         *

    47  */

    48 

    49 typedef struct StringSpriteToDraw {

    50 	uint16 string;

    51 	uint16 color;

    52 	struct StringSpriteToDraw *next;

    53 	int32 x;

    54 	int32 y;

    55 	uint32 params[2];

    56 	uint16 width;

    57 } StringSpriteToDraw;

    58 

    59 typedef struct TileSpriteToDraw {

    60 	uint32 image;

    61 	struct TileSpriteToDraw *next;

    62 	int32 x;

    63 	int32 y;

    64 	byte z;

    65 } TileSpriteToDraw;

    66 

    67 typedef struct ChildScreenSpriteToDraw {

    68 	uint32 image;

    69 	int32 x;

    70 	int32 y;

    71 	struct ChildScreenSpriteToDraw *next;

    72 } ChildScreenSpriteToDraw;

    73 

    74 typedef struct ParentSpriteToDraw {

    75 	uint32 image;

    76 	int32 left;

    77 	int32 top;

    78 	int32 right;

    79 	int32 bottom;

    80 	int32 xmin;

    81 	int32 ymin;

    82 	int32 xmax;

    83 	int32 ymax;

    84 	ChildScreenSpriteToDraw *child;

    85 	byte unk16;

    86 	byte zmin;

    87 	byte zmax;

    88 } ParentSpriteToDraw;

    89 

    90 // Quick hack to know how much memory to reserve when allocating from the spritelist

    91 // to prevent a buffer overflow.

    92 #define LARGEST_SPRITELIST_STRUCT ParentSpriteToDraw

    93 

    94 typedef struct ViewportDrawer {

    95 	DrawPixelInfo dpi;

    96 

    97 	byte *spritelist_mem;

    98 	const byte *eof_spritelist_mem;

    99 

   100 	StringSpriteToDraw **last_string, *first_string;

   101 	TileSpriteToDraw **last_tile, *first_tile;

   102 

   103 	ChildScreenSpriteToDraw **last_child;

   104 

   105 	ParentSpriteToDraw **parent_list;

   106 	ParentSpriteToDraw * const *eof_parent_list;

   107 

   108 	byte combine_sprites;

   109 

   110 	int offs_x, offs_y; // used when drawing ground sprites relative

   111 } ViewportDrawer;

   112 

   113 static ViewportDrawer *_cur_vd;

   114 

   115 TileHighlightData _thd;

   116 static TileInfo *_cur_ti;

   117 

   118 extern void SmallMapCenterOnCurrentPos(Window *w);

   119 

   120 static Point MapXYZToViewport(const ViewPort *vp, uint x, uint y, uint z)

   121 {

   122 	Point p = RemapCoords(x, y, z);

   123 	p.x -= vp->virtual_width / 2;

   124 	p.y -= vp->virtual_height / 2;

   125 	return p;

   126 }

   127 

   128 void InitViewports(void) {

   129 	memset(_viewports, 0, sizeof(_viewports));

   130 	_active_viewports = 0;

   131 }

   132 

   133 void DeleteWindowViewport(Window *w)

   134 {

   135 	CLRBIT(_active_viewports, w->viewport - _viewports);

   136 	w->viewport->width = 0;

   137 	w->viewport = NULL;

   138 }

   139 

   140 void AssignWindowViewport(Window *w, int x, int y,

   141 	int width, int height, uint32 follow_flags, byte zoom)

   142 {

   143 	ViewPort *vp;

   144 	Point pt;

   145 	uint32 bit;

   146 

   147 	for (vp = _viewports, bit = 0; ; vp++, bit++) {

   148 		assert(vp != endof(_viewports));

   149 		if (vp->width == 0) break;

   150 	}

   151 	SETBIT(_active_viewports, bit);

   152 

   153 	vp->left = x + w->left;

   154 	vp->top = y + w->top;

   155 	vp->width = width;

   156 	vp->height = height;

   157 

   158 	vp->zoom = zoom;

   159 

   160 	vp->virtual_width = width << zoom;

   161 	vp->virtual_height = height << zoom;

   162 

   163 	if (follow_flags & 0x80000000) {

   164 		const Vehicle *veh;

   165 

   166 		WP(w, vp_d).follow_vehicle = (VehicleID)(follow_flags & 0xFFFF);

   167 		veh = GetVehicle(WP(w, vp_d).follow_vehicle);

   168 		pt = MapXYZToViewport(vp, veh->x_pos, veh->y_pos, veh->z_pos);

   169 	} else {

   170 		uint x = TileX(follow_flags) * TILE_SIZE;

   171 		uint y = TileY(follow_flags) * TILE_SIZE;

   172 

   173 		WP(w, vp_d).follow_vehicle = INVALID_VEHICLE;

   174 		pt = MapXYZToViewport(vp, x, y, GetSlopeZ(x, y));

   175 	}

   176 

   177 	WP(w, vp_d).scrollpos_x = pt.x;

   178 	WP(w, vp_d).scrollpos_y = pt.y;

   179 	w->viewport = vp;

   180 	vp->virtual_left = 0;//pt.x;

   181 	vp->virtual_top = 0;//pt.y;

   182 }

   183 

   184 static Point _vp_move_offs;

   185 

   186 static void DoSetViewportPosition(Window* const *wz, int left, int top, int width, int height)

   187 {

   188 

   189 	for (; wz != _last_z_window; wz++) {

   190 		const Window *w = *wz;

   191 

   192 		if (left + width > w->left &&

   193 				w->left + w->width > left &&

   194 				top + height > w->top &&

   195 				w->top + w->height > top) {

   196 

   197 			if (left < w->left) {

   198 				DoSetViewportPosition(wz, left, top, w->left - left, height);

   199 				DoSetViewportPosition(wz, left + (w->left - left), top, width - (w->left - left), height);

   200 				return;

   201 			}

   202 

   203 			if (left + width > w->left + w->width) {

   204 				DoSetViewportPosition(wz, left, top, (w->left + w->width - left), height);

   205 				DoSetViewportPosition(wz, left + (w->left + w->width - left), top, width - (w->left + w->width - left) , height);

   206 				return;

   207 			}

   208 

   209 			if (top < w->top) {

   210 				DoSetViewportPosition(wz, left, top, width, (w->top - top));

   211 				DoSetViewportPosition(wz, left, top + (w->top - top), width, height - (w->top - top));

   212 				return;

   213 			}

   214 

   215 			if (top + height > w->top + w->height) {

   216 				DoSetViewportPosition(wz, left, top, width, (w->top + w->height - top));

   217 				DoSetViewportPosition(wz, left, top + (w->top + w->height - top), width , height - (w->top + w->height - top));

   218 				return;

   219 			}

   220 

   221 			return;

   222 		}

   223 	}

   224 

   225 	{

   226 		int xo = _vp_move_offs.x;

   227 		int yo = _vp_move_offs.y;

   228 

   229 		if (abs(xo) >= width || abs(yo) >= height) {

   230 			/* fully_outside */

   231 			RedrawScreenRect(left, top, left + width, top + height);

   232 			return;

   233 		}

   234 

   235 		GfxScroll(left, top, width, height, xo, yo);

   236 

   237 		if (xo > 0) {

   238 			RedrawScreenRect(left, top, xo + left, top + height);

   239 			left += xo;

   240 			width -= xo;

   241 		} else if (xo < 0) {

   242 			RedrawScreenRect(left+width+xo, top, left+width, top + height);

   243 			width += xo;

   244 		}

   245 

   246 		if (yo > 0) {

   247 			RedrawScreenRect(left, top, width+left, top + yo);

   248 		} else if (yo < 0) {

   249 			RedrawScreenRect(left, top + height + yo, width+left, top + height);

   250 		}

   251 	}

   252 }

   253 

   254 static void SetViewportPosition(Window *w, int x, int y)

   255 {

   256 	ViewPort *vp = w->viewport;

   257 	int old_left = vp->virtual_left;

   258 	int old_top = vp->virtual_top;

   259 	int i;

   260 	int left, top, width, height;

   261 

   262 	vp->virtual_left = x;

   263 	vp->virtual_top = y;

   264 

   265 	old_left >>= vp->zoom;

   266 	old_top >>= vp->zoom;

   267 	x >>= vp->zoom;

   268 	y >>= vp->zoom;

   269 

   270 	old_left -= x;

   271 	old_top -= y;

   272 

   273 	if (old_top == 0 && old_left == 0) return;

   274 

   275 	_vp_move_offs.x = old_left;

   276 	_vp_move_offs.y = old_top;

   277 

   278 	left = vp->left;

   279 	top = vp->top;

   280 	width = vp->width;

   281 	height = vp->height;

   282 

   283 	if (left < 0) {

   284 		width += left;

   285 		left = 0;

   286 	}

   287 

   288 	i = left + width - _screen.width;

   289 	if (i >= 0) width -= i;

   290 

   291 	if (width > 0) {

   292 		if (top < 0) {

   293 			height += top;

   294 			top = 0;

   295 		}

   296 

   297 		i = top + height - _screen.height;

   298 		if (i >= 0) height -= i;

   299 

   300 		if (height > 0) DoSetViewportPosition(FindWindowZPosition(w) + 1, left, top, width, height);

   301 	}

   302 }

   303 

   304 

   305 ViewPort *IsPtInWindowViewport(const Window *w, int x, int y)

   306 {

   307 	ViewPort *vp = w->viewport;

   308 

   309 	if (vp != NULL &&

   310 	    IS_INT_INSIDE(x, vp->left, vp->left + vp->width) &&

   311 			IS_INT_INSIDE(y, vp->top, vp->top + vp->height))

   312 		return vp;

   313 

   314 	return NULL;

   315 }

   316 

   317 static Point TranslateXYToTileCoord(const ViewPort *vp, int x, int y)

   318 {

   319 	Point pt;

   320 	int a,b;

   321 	uint z;

   322 

   323 	if ( (uint)(x -= vp->left) >= (uint)vp->width ||

   324 				(uint)(y -= vp->top) >= (uint)vp->height) {

   325 				Point pt = {-1, -1};

   326 				return pt;

   327 	}

   328 

   329 	x = ((x << vp->zoom) + vp->virtual_left) >> 2;

   330 	y = ((y << vp->zoom) + vp->virtual_top) >> 1;

   331 

   332 	a = y-x;

   333 	b = y+x;

   334 

   335 	/* we need to move variables in to the valid range, as the

   336 	 * GetTileZoomCenterWindow() function can call here with invalid x and/or y,

   337 	 * when the user tries to zoom out along the sides of the map */

   338 	a = clamp(a, 0, (int)(MapMaxX() * TILE_SIZE) - 1);

   339 	b = clamp(b, 0, (int)(MapMaxY() * TILE_SIZE) - 1);

   340 

   341 	z = GetSlopeZ(a,     b    ) / 2;

   342 	z = GetSlopeZ(a + z, b + z) / 2;

   343 	z = GetSlopeZ(a + z, b + z) / 2;

   344 	z = GetSlopeZ(a + z, b + z) / 2;

   345 	z = GetSlopeZ(a + z, b + z) / 2;

   346 

   347 	pt.x = a + z;

   348 	pt.y = b + z;

   349 

   350 	return pt;

   351 }

   352 

   353 /* When used for zooming, check area below current coordinates (x,y)

   354  * and return the tile of the zoomed out/in position (zoom_x, zoom_y)

   355  * when you just want the tile, make x = zoom_x and y = zoom_y */

   356 static Point GetTileFromScreenXY(int x, int y, int zoom_x, int zoom_y)

   357 {

   358 	Window *w;

   359 	ViewPort *vp;

   360 	Point pt;

   361 

   362 	if ( (w = FindWindowFromPt(x, y)) != NULL &&

   363 			 (vp = IsPtInWindowViewport(w, x, y)) != NULL)

   364 				return TranslateXYToTileCoord(vp, zoom_x, zoom_y);

   365 

   366 	pt.y = pt.x = -1;

   367 	return pt;

   368 }

   369 

   370 Point GetTileBelowCursor(void)

   371 {

   372 	return GetTileFromScreenXY(_cursor.pos.x, _cursor.pos.y, _cursor.pos.x, _cursor.pos.y);

   373 }

   374 

   375 

   376 Point GetTileZoomCenterWindow(bool in, Window * w)

   377 {

   378 	int x, y;

   379 	ViewPort * vp;

   380 

   381 	vp = w->viewport;

   382 

   383 	if (in) {

   384 		x = ((_cursor.pos.x - vp->left) >> 1) + (vp->width >> 2);

   385 		y = ((_cursor.pos.y - vp->top) >> 1) + (vp->height >> 2);

   386 	} else {

   387 		x = vp->width - (_cursor.pos.x - vp->left);

   388 		y = vp->height - (_cursor.pos.y - vp->top);

   389 	}

   390 	/* Get the tile below the cursor and center on the zoomed-out center */

   391 	return GetTileFromScreenXY(_cursor.pos.x, _cursor.pos.y, x + vp->left, y + vp->top);

   392 }

   393 

   394 /** Update the status of the zoom-buttons according to the zoom-level

   395  * of the viewport. This will update their status and invalidate accordingly

   396  * @param window pointer to the window that has the zoom buttons

   397  * @param vp pointer to the viewport whose zoom-level the buttons represent

   398  * @param widget_zoom_in widget index for window with zoom-in button

   399  * @param widget_zoom_out widget index for window with zoom-out button */

   400 void HandleZoomMessage(Window *w, const ViewPort *vp, byte widget_zoom_in, byte widget_zoom_out)

   401 {

   402 	SetWindowWidgetDisabledState(w, widget_zoom_in, vp->zoom == 0);

   403 	InvalidateWidget(w, widget_zoom_in);

   404 

   405 	SetWindowWidgetDisabledState(w, widget_zoom_out, vp->zoom == 2);

   406 	InvalidateWidget(w, widget_zoom_out);

   407 }

   408 

   409 void DrawGroundSpriteAt(uint32 image, int32 x, int32 y, byte z)

   410 {

   411 	ViewportDrawer *vd = _cur_vd;

   412 	TileSpriteToDraw *ts;

   413 

   414 	assert((image & SPRITE_MASK) < MAX_SPRITES);

   415 

   416 	if (vd->spritelist_mem >= vd->eof_spritelist_mem) {

   417 		DEBUG(sprite, 0, "Out of sprite memory");

   418 		return;

   419 	}

   420 	ts = (TileSpriteToDraw*)vd->spritelist_mem;

   421 

   422 	vd->spritelist_mem += sizeof(TileSpriteToDraw);

   423 

   424 	ts->image = image;

   425 	ts->next = NULL;

   426 	ts->x = x;

   427 	ts->y = y;

   428 	ts->z = z;

   429 	*vd->last_tile = ts;

   430 	vd->last_tile = &ts->next;

   431 }

   432 

   433 void DrawGroundSprite(uint32 image)

   434 {

   435 	if (_offset_ground_sprites) {

   436 		// offset ground sprite because of foundation?

   437 		AddChildSpriteScreen(image, _cur_vd->offs_x, _cur_vd->offs_y);

   438 	} else {

   439 		_added_tile_sprite = true;

   440 		DrawGroundSpriteAt(image, _cur_ti->x, _cur_ti->y, _cur_ti->z);

   441 	}

   442 }

   443 

   444 

   445 void OffsetGroundSprite(int x, int y)

   446 {

   447 	_cur_vd->offs_x = x;

   448 	_cur_vd->offs_y = y;

   449 	_offset_ground_sprites = true;

   450 }

   451 

   452 static void AddCombinedSprite(uint32 image, int x, int y, byte z)

   453 {

   454 	const ViewportDrawer *vd = _cur_vd;

   455 	Point pt = RemapCoords(x, y, z);

   456 	const Sprite* spr = GetSprite(image & SPRITE_MASK);

   457 

   458 	if (pt.x + spr->x_offs >= vd->dpi.left + vd->dpi.width ||

   459 			pt.x + spr->x_offs + spr->width <= vd->dpi.left ||

   460 			pt.y + spr->y_offs >= vd->dpi.top + vd->dpi.height ||

   461 			pt.y + spr->y_offs + spr->height <= vd->dpi.top)

   462 		return;

   463 

   464 	AddChildSpriteScreen(image, pt.x - vd->parent_list[-1]->left, pt.y - vd->parent_list[-1]->top);

   465 }

   466 

   467 

   468 void AddSortableSpriteToDraw(uint32 image, int x, int y, int w, int h, byte dz, byte z)

   469 {

   470 	ViewportDrawer *vd = _cur_vd;

   471 	ParentSpriteToDraw *ps;

   472 	const Sprite *spr;

   473 	Point pt;

   474 

   475 	assert((image & SPRITE_MASK) < MAX_SPRITES);

   476 

   477 	if (vd->combine_sprites == 2) {

   478 		AddCombinedSprite(image, x, y, z);

   479 		return;

   480 	}

   481 

   482 	vd->last_child = NULL;

   483 

   484 	if (vd->spritelist_mem >= vd->eof_spritelist_mem) {

   485 		DEBUG(sprite, 0, "Out of sprite memory");

   486 		return;

   487 	}

   488 	ps = (ParentSpriteToDraw*)vd->spritelist_mem;

   489 

   490 	if (vd->parent_list >= vd->eof_parent_list) {

   491 		// This can happen rarely, mostly when you zoom out completely

   492 		//  and have a lot of stuff that moves (and is added to the

   493 		//  sort-list, this function). To solve it, increase

   494 		//  parent_list somewhere below to a higher number.

   495 		// This can not really hurt you, it just gives some black

   496 		//  spots on the screen ;)

   497 		DEBUG(sprite, 0, "Out of sprite memory (parent_list)");

   498 		return;

   499 	}

   500 

   501 	pt = RemapCoords(x, y, z);

   502 	spr = GetSprite(image & SPRITE_MASK);

   503 	if ((ps->left   = (pt.x += spr->x_offs)) >= vd->dpi.left + vd->dpi.width ||

   504 			(ps->right  = (pt.x +  spr->width )) <= vd->dpi.left ||

   505 			(ps->top    = (pt.y += spr->y_offs)) >= vd->dpi.top + vd->dpi.height ||

   506 			(ps->bottom = (pt.y +  spr->height)) <= vd->dpi.top) {

   507 		return;

   508 	}

   509 

   510 	vd->spritelist_mem += sizeof(ParentSpriteToDraw);

   511 

   512 	ps->image = image;

   513 	ps->xmin = x;

   514 	ps->xmax = x + w - 1;

   515 

   516 	ps->ymin = y;

   517 	ps->ymax = y + h - 1;

   518 

   519 	ps->zmin = z;

   520 	ps->zmax = z + dz - 1;

   521 

   522 	ps->unk16 = 0;

   523 	ps->child = NULL;

   524 	vd->last_child = &ps->child;

   525 

   526 	*vd->parent_list++ = ps;

   527 

   528 	if (vd->combine_sprites == 1) vd->combine_sprites = 2;

   529 }

   530 

   531 void StartSpriteCombine(void)

   532 {

   533 	_cur_vd->combine_sprites = 1;

   534 }

   535 

   536 void EndSpriteCombine(void)

   537 {

   538 	_cur_vd->combine_sprites = 0;

   539 }

   540 

   541 void AddChildSpriteScreen(uint32 image, int x, int y)

   542 {

   543 	ViewportDrawer *vd = _cur_vd;

   544 	ChildScreenSpriteToDraw *cs;

   545 

   546 	assert((image & SPRITE_MASK) < MAX_SPRITES);

   547 

   548 	if (vd->spritelist_mem >= vd->eof_spritelist_mem) {

   549 		DEBUG(sprite, 0, "Out of sprite memory");

   550 		return;

   551 	}

   552 	cs = (ChildScreenSpriteToDraw*)vd->spritelist_mem;

   553 

   554 	if (vd->last_child == NULL) return;

   555 

   556 	vd->spritelist_mem += sizeof(ChildScreenSpriteToDraw);

   557 

   558 	*vd->last_child = cs;

   559 	vd->last_child = &cs->next;

   560 

   561 	cs->image = image;

   562 	cs->x = x;

   563 	cs->y = y;

   564 	cs->next = NULL;

   565 }

   566 

   567 /* Returns a StringSpriteToDraw */

   568 void *AddStringToDraw(int x, int y, StringID string, uint32 params_1, uint32 params_2)

   569 {

   570 	ViewportDrawer *vd = _cur_vd;

   571 	StringSpriteToDraw *ss;

   572 

   573 	if (vd->spritelist_mem >= vd->eof_spritelist_mem) {

   574 		DEBUG(sprite, 0, "Out of sprite memory");

   575 		return NULL;

   576 	}

   577 	ss = (StringSpriteToDraw*)vd->spritelist_mem;

   578 

   579 	vd->spritelist_mem += sizeof(StringSpriteToDraw);

   580 

   581 	ss->string = string;

   582 	ss->next = NULL;

   583 	ss->x = x;

   584 	ss->y = y;

   585 	ss->params[0] = params_1;

   586 	ss->params[1] = params_2;

   587 	ss->width = 0;

   588 

   589 	*vd->last_string = ss;

   590 	vd->last_string = &ss->next;

   591 

   592 	return ss;

   593 }

   594 

   595 

   596 static void DrawSelectionSprite(uint32 image, const TileInfo *ti)

   597 {

   598 	if (_added_tile_sprite && !(_thd.drawstyle & HT_LINE)) { // draw on real ground

   599 		DrawGroundSpriteAt(image, ti->x, ti->y, ti->z + 7);

   600 	} else { // draw on top of foundation

   601 		AddSortableSpriteToDraw(image, ti->x, ti->y, 0x10, 0x10, 1, ti->z + 7);

   602 	}

   603 }

   604 

   605 static bool IsPartOfAutoLine(int px, int py)

   606 {

   607 	px -= _thd.selstart.x;

   608 	py -= _thd.selstart.y;

   609 

   610 	switch (_thd.drawstyle) {

   611 	case HT_LINE | HT_DIR_X:  return py == 0; // x direction

   612 	case HT_LINE | HT_DIR_Y:  return px == 0; // y direction

   613 	case HT_LINE | HT_DIR_HU: return px == -py || px == -py - 16; // horizontal upper

   614 	case HT_LINE | HT_DIR_HL: return px == -py || px == -py + 16; // horizontal lower

   615 	case HT_LINE | HT_DIR_VL: return px == py || px == py + 16; // vertival left

   616 	case HT_LINE | HT_DIR_VR: return px == py || px == py - 16; // vertical right

   617 	default:

   618 		NOT_REACHED();

   619 	}

   620 

   621 	/* useless, but avoids compiler warning this way */

   622 	return 0;

   623 }

   624 

   625 // [direction][side]

   626 static const int _AutorailType[6][2] = {

   627 	{ HT_DIR_X,  HT_DIR_X },

   628 	{ HT_DIR_Y,  HT_DIR_Y },

   629 	{ HT_DIR_HU, HT_DIR_HL },

   630 	{ HT_DIR_HL, HT_DIR_HU },

   631 	{ HT_DIR_VL, HT_DIR_VR },

   632 	{ HT_DIR_VR, HT_DIR_VL }

   633 };

   634 

   635 #include "table/autorail.h"

   636 

   637 static void DrawTileSelection(const TileInfo *ti)

   638 {

   639 	uint32 image;

   640 

   641 	// Draw a red error square?

   642 	if (_thd.redsq != 0 && _thd.redsq == ti->tile) {

   643 		DrawSelectionSprite(PALETTE_TILE_RED_PULSATING | (SPR_SELECT_TILE + _tileh_to_sprite[ti->tileh]), ti);

   644 		return;

   645 	}

   646 

   647 	// no selection active?

   648 	if (_thd.drawstyle == 0) return;

   649 

   650 	// Inside the inner area?

   651 	if (IS_INSIDE_1D(ti->x, _thd.pos.x, _thd.size.x) &&

   652 			IS_INSIDE_1D(ti->y, _thd.pos.y, _thd.size.y)) {

   653 		if (_thd.drawstyle & HT_RECT) {

   654 			image = SPR_SELECT_TILE + _tileh_to_sprite[ti->tileh];

   655 			if (_thd.make_square_red) image |= PALETTE_SEL_TILE_RED;

   656 			DrawSelectionSprite(image, ti);

   657 		} else if (_thd.drawstyle & HT_POINT) {

   658 			// Figure out the Z coordinate for the single dot.

   659 			byte z = ti->z;

   660 			if (ti->tileh & SLOPE_N) {

   661 				z += TILE_HEIGHT;

   662 				if (ti->tileh == SLOPE_STEEP_N) z += TILE_HEIGHT;

   663 			}

   664 			DrawGroundSpriteAt(_cur_dpi->zoom != 2 ? SPR_DOT : SPR_DOT_SMALL, ti->x, ti->y, z);

   665 		} else if (_thd.drawstyle & HT_RAIL /*&& _thd.place_mode == VHM_RAIL*/) {

   666 			// autorail highlight piece under cursor

   667 			uint type = _thd.drawstyle & 0xF;

   668 			assert(type <= 5);

   669 			image = SPR_AUTORAIL_BASE + _AutorailTilehSprite[ti->tileh][_AutorailType[type][0]];

   670 

   671 			if (_thd.make_square_red) image |= PALETTE_SEL_TILE_RED;

   672 			DrawSelectionSprite(image, ti);

   673 

   674 		} else if (IsPartOfAutoLine(ti->x, ti->y)) {

   675 			// autorail highlighting long line

   676 			int dir = _thd.drawstyle & ~0xF0;

   677 			uint side;

   678 

   679 			if (dir < 2) {

   680 				side = 0;

   681 			} else {

   682 				TileIndex start = TileVirtXY(_thd.selstart.x, _thd.selstart.y);

   683 				int diffx = myabs(TileX(start) - TileX(ti->tile));

   684 				int diffy = myabs(TileY(start) - TileY(ti->tile));

   685 				side = myabs(diffx - diffy);

   686 			}

   687 

   688 			image = SPR_AUTORAIL_BASE + _AutorailTilehSprite[ti->tileh][_AutorailType[dir][side]];

   689 

   690 			if (_thd.make_square_red) image |= PALETTE_SEL_TILE_RED;

   691 			DrawSelectionSprite(image, ti);

   692 		}

   693 		return;

   694 	}

   695 

   696 	// Check if it's inside the outer area?

   697 	if (_thd.outersize.x &&

   698 			_thd.size.x < _thd.size.x + _thd.outersize.x &&

   699 			IS_INSIDE_1D(ti->x, _thd.pos.x + _thd.offs.x, _thd.size.x + _thd.outersize.x) &&

   700 			IS_INSIDE_1D(ti->y, _thd.pos.y + _thd.offs.y, _thd.size.y + _thd.outersize.y)) {

   701 		// Draw a blue rect.

   702 		DrawSelectionSprite(PALETTE_SEL_TILE_BLUE | (SPR_SELECT_TILE + _tileh_to_sprite[ti->tileh]), ti);

   703 		return;

   704 	}

   705 }

   706 

   707 static void ViewportAddLandscape(void)

   708 {

   709 	ViewportDrawer *vd = _cur_vd;

   710 	int x, y, width, height;

   711 	TileInfo ti;

   712 	bool direction;

   713 

   714 	_cur_ti = &ti;

   715 

   716 	// Transform into tile coordinates and round to closest full tile

   717 	x = ((vd->dpi.top >> 1) - (vd->dpi.left >> 2)) & ~0xF;

   718 	y = ((vd->dpi.top >> 1) + (vd->dpi.left >> 2) - 0x10) & ~0xF;

   719 

   720 	// determine size of area

   721 	{

   722 		Point pt = RemapCoords(x, y, 241);

   723 		width = (vd->dpi.left + vd->dpi.width - pt.x + 95) >> 6;

   724 		height = (vd->dpi.top + vd->dpi.height - pt.y) >> 5 << 1;

   725 	}

   726 

   727 	assert(width > 0);

   728 	assert(height > 0);

   729 

   730 	direction = false;

   731 

   732 	do {

   733 		int width_cur = width;

   734 		int x_cur = x;

   735 		int y_cur = y;

   736 

   737 		do {

   738 			TileType tt;

   739 

   740 			ti.x = x_cur;

   741 			ti.y = y_cur;

   742 			if (0 <= x_cur && x_cur < (int)MapMaxX() * TILE_SIZE &&

   743 					0 <= y_cur && y_cur < (int)MapMaxY() * TILE_SIZE) {

   744 				TileIndex tile = TileVirtXY(x_cur, y_cur);

   745 

   746 				ti.tile = tile;

   747 				ti.tileh = GetTileSlope(tile, &ti.z);

   748 				tt = GetTileType(tile);

   749 			} else {

   750 				ti.tileh = SLOPE_FLAT;

   751 				ti.tile = 0;

   752 				ti.z = 0;

   753 				tt = MP_VOID;

   754 			}

   755 

   756 			y_cur += 0x10;

   757 			x_cur -= 0x10;

   758 

   759 			_added_tile_sprite = false;

   760 			_offset_ground_sprites = false;

   761 

   762 			_tile_type_procs[tt]->draw_tile_proc(&ti);

   763 			DrawTileSelection(&ti);

   764 		} while (--width_cur);

   765 

   766 		if ((direction ^= 1) != 0) {

   767 			y += 0x10;

   768 		} else {

   769 			x += 0x10;

   770 		}

   771 	} while (--height);

   772 }

   773 

   774 

   775 static void ViewportAddTownNames(DrawPixelInfo *dpi)

   776 {

   777 	Town *t;

   778 	int left, top, right, bottom;

   779 

   780 	if (!(_display_opt & DO_SHOW_TOWN_NAMES) || _game_mode == GM_MENU)

   781 		return;

   782 

   783 	left = dpi->left;

   784 	top = dpi->top;

   785 	right = left + dpi->width;

   786 	bottom = top + dpi->height;

   787 

   788 	switch (dpi->zoom) {

   789 		case 0:

   790 			FOR_ALL_TOWNS(t) {

   791 				if (bottom > t->sign.top &&

   792 						top    < t->sign.top + 12 &&

   793 						right  > t->sign.left &&

   794 						left   < t->sign.left + t->sign.width_1) {

   795 					AddStringToDraw(t->sign.left + 1, t->sign.top + 1,

   796 						_patches.population_in_label ? STR_TOWN_LABEL_POP : STR_TOWN_LABEL,

   797 						t->index, t->population);

   798 				}

   799 			}

   800 			break;

   801 

   802 		case 1:

   803 			right += 2;

   804 			bottom += 2;

   805 

   806 			FOR_ALL_TOWNS(t) {

   807 				if (bottom > t->sign.top &&

   808 						top    < t->sign.top + 24 &&

   809 						right  > t->sign.left &&

   810 						left   < t->sign.left + t->sign.width_1*2) {

   811 					AddStringToDraw(t->sign.left + 1, t->sign.top + 1,

   812 						_patches.population_in_label ? STR_TOWN_LABEL_POP : STR_TOWN_LABEL,

   813 						t->index, t->population);

   814 				}

   815 			}

   816 			break;

   817 

   818 		default: NOT_REACHED();

   819 		case 2:

   820 			right += 4;

   821 			bottom += 5;

   822 

   823 			FOR_ALL_TOWNS(t) {

   824 				if (bottom > t->sign.top &&

   825 						top    < t->sign.top + 24 &&

   826 						right  > t->sign.left &&

   827 						left   < t->sign.left + t->sign.width_2*4) {

   828 					AddStringToDraw(t->sign.left + 5, t->sign.top + 1, STR_TOWN_LABEL_TINY_BLACK, t->index, 0);

   829 					AddStringToDraw(t->sign.left + 1, t->sign.top - 3, STR_TOWN_LABEL_TINY_WHITE, t->index, 0);

   830 				}

   831 			}

   832 			break;

   833 	}

   834 }

   835 

   836 

   837 static void AddStation(const Station *st, StringID str, uint16 width)

   838 {

   839 	StringSpriteToDraw *sstd;

   840 

   841 	sstd = AddStringToDraw(st->sign.left + 1, st->sign.top + 1, str, st->index, st->facilities);

   842 	if (sstd != NULL) {

   843 		sstd->color = (st->owner == OWNER_NONE || st->facilities == 0) ? 0xE : _player_colors[st->owner];

   844 		sstd->width = width;

   845 	}

   846 }

   847 

   848 

   849 static void ViewportAddStationNames(DrawPixelInfo *dpi)

   850 {

   851 	int left, top, right, bottom;

   852 	const Station *st;

   853 

   854 	if (!(_display_opt & DO_SHOW_STATION_NAMES) || _game_mode == GM_MENU)

   855 		return;

   856 

   857 	left = dpi->left;

   858 	top = dpi->top;

   859 	right = left + dpi->width;

   860 	bottom = top + dpi->height;

   861 

   862 	switch (dpi->zoom) {

   863 		case 0:

   864 			FOR_ALL_STATIONS(st) {

   865 				if (bottom > st->sign.top &&

   866 						top    < st->sign.top + 12 &&

   867 						right  > st->sign.left &&

   868 						left   < st->sign.left + st->sign.width_1) {

   869 					AddStation(st, STR_305C_0, st->sign.width_1);

   870 				}

   871 			}

   872 			break;

   873 

   874 		case 1:

   875 			right += 2;

   876 			bottom += 2;

   877 			FOR_ALL_STATIONS(st) {

   878 				if (bottom > st->sign.top &&

   879 						top    < st->sign.top + 24 &&

   880 						right  > st->sign.left &&

   881 						left   < st->sign.left + st->sign.width_1*2) {

   882 					AddStation(st, STR_305C_0, st->sign.width_1);

   883 				}

   884 			}

   885 			break;

   886 

   887 		default: NOT_REACHED();

   888 		case 2:

   889 			right += 4;

   890 			bottom += 5;

   891 			FOR_ALL_STATIONS(st) {

   892 				if (bottom > st->sign.top &&

   893 						top    < st->sign.top + 24 &&

   894 						right  > st->sign.left &&

   895 						left   < st->sign.left + st->sign.width_2*4) {

   896 					AddStation(st, STR_STATION_SIGN_TINY, st->sign.width_2 | 0x8000);

   897 				}

   898 			}

   899 			break;

   900 	}

   901 }

   902 

   903 

   904 static void AddSign(const Sign *si, StringID str, uint16 width)

   905 {

   906 	StringSpriteToDraw *sstd;

   907 

   908 	sstd = AddStringToDraw(si->sign.left + 1, si->sign.top + 1, str, si->str, 0);

   909 	if (sstd != NULL) {

   910 		sstd->color = (si->owner == OWNER_NONE) ? 14 : _player_colors[si->owner];

   911 		sstd->width = width;

   912 	}

   913 }

   914 

   915 

   916 static void ViewportAddSigns(DrawPixelInfo *dpi)

   917 {

   918 	const Sign *si;

   919 	int left, top, right, bottom;

   920 

   921 	if (!(_display_opt & DO_SHOW_SIGNS))

   922 		return;

   923 

   924 	left = dpi->left;

   925 	top = dpi->top;

   926 	right = left + dpi->width;

   927 	bottom = top + dpi->height;

   928 

   929 	switch (dpi->zoom) {

   930 		case 0:

   931 			FOR_ALL_SIGNS(si) {

   932 				if (bottom > si->sign.top &&

   933 						top    < si->sign.top + 12 &&

   934 						right  > si->sign.left &&

   935 						left   < si->sign.left + si->sign.width_1) {

   936 					AddSign(si, STR_2806, si->sign.width_1);

   937 				}

   938 			}

   939 			break;

   940 

   941 		case 1:

   942 			right += 2;

   943 			bottom += 2;

   944 			FOR_ALL_SIGNS(si) {

   945 				if (bottom > si->sign.top &&

   946 						top    < si->sign.top + 24 &&

   947 						right  > si->sign.left &&

   948 						left   < si->sign.left + si->sign.width_1 * 2) {

   949 					AddSign(si, STR_2806, si->sign.width_1);

   950 				}

   951 			}

   952 			break;

   953 

   954 		default: NOT_REACHED();

   955 		case 2:

   956 			right += 4;

   957 			bottom += 5;

   958 			FOR_ALL_SIGNS(si) {

   959 				if (bottom > si->sign.top &&

   960 						top    < si->sign.top + 24 &&

   961 						right  > si->sign.left &&

   962 						left   < si->sign.left + si->sign.width_2 * 4) {

   963 					AddSign(si, STR_2002, si->sign.width_2 | 0x8000);

   964 				}

   965 			}

   966 			break;

   967 	}

   968 }

   969 

   970 

   971 static void AddWaypoint(const Waypoint *wp, StringID str, uint16 width)

   972 {

   973 	StringSpriteToDraw *sstd;

   974 

   975 	sstd = AddStringToDraw(wp->sign.left + 1, wp->sign.top + 1, str, wp->index, 0);

   976 	if (sstd != NULL) {

   977 		sstd->color = (wp->deleted ? 0xE : 11);

   978 		sstd->width = width;

   979 	}

   980 }

   981 

   982 

   983 static void ViewportAddWaypoints(DrawPixelInfo *dpi)

   984 {

   985 	const Waypoint *wp;

   986 	int left, top, right, bottom;

   987 

   988 	if (!(_display_opt & DO_WAYPOINTS))

   989 		return;

   990 

   991 	left = dpi->left;

   992 	top = dpi->top;

   993 	right = left + dpi->width;

   994 	bottom = top + dpi->height;

   995 

   996 	switch (dpi->zoom) {

   997 		case 0:

   998 			FOR_ALL_WAYPOINTS(wp) {

   999 				if (bottom > wp->sign.top &&

  1000 						top    < wp->sign.top + 12 &&

  1001 						right  > wp->sign.left &&

  1002 						left   < wp->sign.left + wp->sign.width_1) {

  1003 					AddWaypoint(wp, STR_WAYPOINT_VIEWPORT, wp->sign.width_1);

  1004 				}

  1005 			}

  1006 			break;

  1007 

  1008 		case 1:

  1009 			right += 2;

  1010 			bottom += 2;

  1011 			FOR_ALL_WAYPOINTS(wp) {

  1012 				if (bottom > wp->sign.top &&

  1013 						top    < wp->sign.top + 24 &&

  1014 						right  > wp->sign.left &&

  1015 						left   < wp->sign.left + wp->sign.width_1*2) {

  1016 					AddWaypoint(wp, STR_WAYPOINT_VIEWPORT, wp->sign.width_1);

  1017 				}

  1018 			}

  1019 			break;

  1020 

  1021 		default: NOT_REACHED();

  1022 		case 2:

  1023 			right += 4;

  1024 			bottom += 5;

  1025 			FOR_ALL_WAYPOINTS(wp) {

  1026 				if (bottom > wp->sign.top &&

  1027 						top    < wp->sign.top + 24 &&

  1028 						right  > wp->sign.left &&

  1029 						left   < wp->sign.left + wp->sign.width_2*4) {

  1030 					AddWaypoint(wp, STR_WAYPOINT_VIEWPORT_TINY, wp->sign.width_2 | 0x8000);

  1031 				}

  1032 			}

  1033 			break;

  1034 	}

  1035 }

  1036 

  1037 void UpdateViewportSignPos(ViewportSign *sign, int left, int top, StringID str)

  1038 {

  1039 	char buffer[128];

  1040 	uint w;

  1041 

  1042 	sign->top = top;

  1043 

  1044 	GetString(buffer, str, lastof(buffer));

  1045 	w = GetStringBoundingBox(buffer).width + 3;

  1046 	sign->width_1 = w;

  1047 	sign->left = left - w / 2;

  1048 

  1049 	/* zoomed out version */

  1050 	_cur_fontsize = FS_SMALL;

  1051 	w = GetStringBoundingBox(buffer).width + 3;

  1052 	_cur_fontsize = FS_NORMAL;

  1053 	sign->width_2 = w;

  1054 }

  1055 

  1056 

  1057 static void ViewportDrawTileSprites(TileSpriteToDraw *ts)

  1058 {

  1059 	do {

  1060 		Point pt = RemapCoords(ts->x, ts->y, ts->z);

  1061 		DrawSprite(ts->image, pt.x, pt.y);

  1062 		ts = ts->next;

  1063 	} while (ts != NULL);

  1064 }

  1065 

  1066 static void ViewportSortParentSprites(ParentSpriteToDraw *psd[])

  1067 {

  1068 	while (*psd != NULL) {

  1069 		ParentSpriteToDraw* ps = *psd;

  1070 

  1071 		if (!(ps->unk16 & 1)) {

  1072 			ParentSpriteToDraw** psd2 = psd;

  1073 

  1074 			ps->unk16 |= 1;

  1075 

  1076 			while (*++psd2 != NULL) {

  1077 				ParentSpriteToDraw* ps2 = *psd2;

  1078 				ParentSpriteToDraw** psd3;

  1079 

  1080 				if (ps2->unk16 & 1) continue;

  1081 

  1082 				/* Decide which comparator to use, based on whether the bounding

  1083 				 * boxes overlap

  1084 				 */

  1085 				if (ps->xmax > ps2->xmin && ps->xmin < ps2->xmax && // overlap in X?

  1086 						ps->ymax > ps2->ymin && ps->ymin < ps2->ymax && // overlap in Y?

  1087 						ps->zmax > ps2->zmin && ps->zmin < ps2->zmax) { // overlap in Z?

  1088 					/* Use X+Y+Z as the sorting order, so sprites closer to the bottom of

  1089 					 * the screen and with higher Z elevation, are drawn in front.

  1090 					 * Here X,Y,Z are the coordinates of the "center of mass" of the sprite,

  1091 					 * i.e. X=(left+right)/2, etc.

  1092 					 * However, since we only care about order, don't actually divide / 2

  1093 					 */

  1094 					if (ps->xmin + ps->xmax + ps->ymin + ps->ymax + ps->zmin + ps->zmax <=

  1095 							ps2->xmin + ps2->xmax + ps2->ymin + ps2->ymax + ps2->zmin + ps2->zmax) {

  1096 						continue;

  1097 					}

  1098 				} else {

  1099 					if (ps->xmax < ps2->xmin ||

  1100 							ps->ymax < ps2->ymin ||

  1101 							ps->zmax < ps2->zmin || (

  1102 								ps->xmin < ps2->xmax &&

  1103 								ps->ymin < ps2->ymax &&

  1104 								ps->zmin < ps2->zmax

  1105 							)) {

  1106 						continue;

  1107 					}

  1108 				}

  1109 

  1110 				// Swap the two sprites ps and ps2 using bubble-sort algorithm.

  1111 				psd3 = psd;

  1112 				do {

  1113 					ParentSpriteToDraw* temp = *psd3;

  1114 					*psd3 = ps2;

  1115 					ps2 = temp;

  1116 

  1117 					psd3++;

  1118 				} while (psd3 <= psd2);

  1119 			}

  1120 		} else {

  1121 			psd++;

  1122 		}

  1123 	}

  1124 }

  1125 

  1126 static void ViewportDrawParentSprites(ParentSpriteToDraw *psd[])

  1127 {

  1128 	for (; *psd != NULL; psd++) {

  1129 		const ParentSpriteToDraw* ps = *psd;

  1130 		Point pt = RemapCoords(ps->xmin, ps->ymin, ps->zmin);

  1131 		const ChildScreenSpriteToDraw* cs;

  1132 

  1133 		DrawSprite(ps->image, pt.x, pt.y);

  1134 

  1135 		for (cs = ps->child; cs != NULL; cs = cs->next) {

  1136 			DrawSprite(cs->image, ps->left + cs->x, ps->top + cs->y);