uint pos = (log->count + log->pos - i) % log->count;

			if (log->lines[pos] == NULL) break;

			switch (log->type[pos]) {

				case AILog::LOG_SQ_INFO:  colour = TC_BLACK;  break;

				case AILog::LOG_SQ_ERROR: colour = TC_RED;    break;

		if (_settings_game.economy.station_noise_level) {

			/* show the noise of the selected airport */

			SetDParam(0, airport->noise_level);

			y_noise_offset = 10;

		}

	static int size;            ///< The amount of items in the backlog

	IConsoleLine *previous; ///< The previous console message.

	/**

	 * Initialize the console line.

	 * @param buffer the data to print.

	 * @param colour the colour of the line.

	 */

			previous(IConsoleLine::front),

			buffer(buffer),

			colour(colour),

		/* If the text is longer than the window, don't show the starting ']' */

		int delta = this->width - 10 - _iconsole_cmdline.width - ICON_RIGHT_BORDERWIDTH;

		if (delta > 0) {

			delta = 0;

		}

		if (_focused_window == this && _iconsole_cmdline.caret) {

			DoDrawString("_", 10 + delta + _iconsole_cmdline.caretxoffs, this->height - ICON_LINE_HEIGHT, TC_WHITE);

 */

void IConsoleGUIPrint(ConsoleColour color_code, char *str)

{

	SetWindowDirty(FindWindowById(WC_CONSOLE, 0));

}

byte _colour_gradient[COLOUR_END][8];

static void GfxMainBlitter(const Sprite *sprite, int x, int y, BlitterMode mode, const SubSprite *sub = NULL);

FontSize _cur_fontsize;

static FontSize _last_fontsize;

 * @ingroup dirty

 */

static Rect _invalid_rect;

enum {

	DIRTY_BLOCK_HEIGHT   = 8,

 * @param top Minimum Y (inclusive)

 * @param right Maximum X (inclusive)

 * @param bottom Maximum Y (inclusive)

 * @param mode

 *         FILLRECT_CHECKER:  Like FILLRECT_OPAQUE, but only draw every second pixel (used to grey out things)

 */

{

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

	const DrawPixelInfo *dpi = _cur_dpi;

	switch (mode) {

		default: // FILLRECT_OPAQUE

			break;

		case FILLRECT_RECOLOR:

			break;

		case FILLRECT_CHECKER: {

			byte bo = (oleft - left + dpi->left + otop - top + dpi->top) & 1;

			do {

				dst = blitter->MoveTo(dst, 0, 1);

			} while (--bottom > 0);

			break;

	}

}

{

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

	DrawPixelInfo *dpi = _cur_dpi;

	if (x > dpi->width  && x2 > dpi->width)  return;

	if (y > dpi->height && y2 > dpi->height) return;

}

{

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

	DrawPixelInfo *dpi = _cur_dpi;

	blitter->DrawLine(dpi->dst_ptr, UnScaleByZoom(x, dpi->zoom), UnScaleByZoom(y, dpi->zoom),

			UnScaleByZoom(x2, dpi->zoom), UnScaleByZoom(y2, dpi->zoom),

}

/**

	 *            ....V.

	 */

}

 * @param x      X position to start drawing

 * @param y      Y position to start drawing

 * @param str    String to draw

 *

 * @return Horizontal coordinate after drawing the string

 */

{

	char buffer[DRAW_STRING_BUFFER];

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

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

}

/**

 * @param x      X position to start drawing

 * @param y      Y position to start drawing

 * @param str    String to draw

 * @param maxw   Maximal width of the string

 *

 * @return Horizontal coordinate after drawing the (possibly truncated) string

 */

{

	char buffer[DRAW_STRING_BUFFER];

	TruncateStringID(str, buffer, maxw, lastof(buffer));

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

}

/**

 * @param x      Right-most x position of the string

 * @param y      Y position of the string

 * @param str    String to draw

 *

 * @return Width of drawn string in pixels

 */

{

	char buffer[DRAW_STRING_BUFFER];

	int w;

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	w = GetStringBoundingBox(buffer).width;

	return w;

}

 * @param x      Right-most x position to start drawing

 * @param y      Y position to start drawing

 * @param str    String to draw

 * @param maxw   Maximal width of the string

 */

{

	char buffer[DRAW_STRING_BUFFER];

	TruncateStringID(str, buffer, maxw, lastof(buffer));

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

}

/**

 * @param x      Right-most x position of the string

 * @param y      Y position of the string

 * @param str    String to draw

 */

{

}

/**

 * @param x      X position of center of the string

 * @param y      Y position of center of the string

 * @param str    String to draw

 *

 * @return Width of the drawn string in pixels

 */

{

	char buffer[DRAW_STRING_BUFFER];

	int w;

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	w = GetStringBoundingBox(buffer).width;

	return w;

}

 * @param xr     Right-most x position

 * @param y      Y position of the string

 * @param str    String to draw

 *

 * @return Right-most coordinate of the (possibly truncated) drawn string

 */

{

	char buffer[DRAW_STRING_BUFFER];

	TruncateStringID(str, buffer, xr - xl, lastof(buffer));

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	int w = GetStringBoundingBox(buffer).width;

}

/**

 * @param x      X position of center of the string

 * @param y      Y position of center of the string

 * @param str    String to draw

 *

 * @return Width of the drawn string in pixels

 */

{

	char buffer[DRAW_STRING_BUFFER];

	strecpy(buffer, str, lastof(buffer));

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

	int w = GetStringBoundingBox(buffer).width;

	return w;

}

 * @param x      X position of center of the string

 * @param y      Y position of center of the string

 * @param str    String to draw

 */

{

}

/**

 * @param xr     Right x position of the string

 * @param y      Y position of center of the string

 * @param str    String to draw

 */

{

}

/**

		strecpy(buf2, src, lastof(buf2));

		HandleBiDiAndArabicShapes(buf2, lastof(buf2));

		int w = GetStringBoundingBox(buf2).width;

		_cur_fontsize = _last_fontsize;

		for (;;) {

		char buf2[DRAW_STRING_BUFFER];

		strecpy(buf2, src, lastof(buf2));

		HandleBiDiAndArabicShapes(buf2, lastof(buf2));

		_cur_fontsize = _last_fontsize;

		for (;;) {

 * @param c           Character (glyph) to draw

 * @param x           X position to draw character

 * @param y           Y position to draw character

 */

{

	FontSize size = FS_NORMAL;

	int w = GetCharacterWidth(size, c);

	GfxMainBlitter(GetGlyph(size, c), x - w / 2, y, BM_COLOUR_REMAP);

}

 * @param string              The string to draw. This is not yet bidi reordered.

 * @param x                   Offset from left side of the screen

 * @param y                   Offset from top side of the screen

 *                            table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h

 * @param parse_string_also_when_clipped

 *                            By default, always test the available space where to draw the string.

 * @return                    the x-coordinates where the drawing has finished.

 *                            If nothing is drawn, the originally passed x-coordinate is returned

 */

{

	char buffer[DRAW_STRING_BUFFER];

	strecpy(buffer, string, lastof(buffer));

	HandleBiDiAndArabicShapes(buffer, lastof(buffer));

}

/** Draw a string at the given coordinates with the given colour.

 * @param string              The string to draw. This is already bidi reordered.

 * @param x                   Offset from left side of the screen

 * @param y                   Offset from top side of the screen

 *                            table/palettes.h or docs/ottd-colourtext-palette.png or the enum TextColour in gfx_type.h

 * @param parse_string_also_when_clipped

 *                            By default, always test the available space where to draw the string.

 * @return                    the x-coordinates where the drawing has finished.

 *                            If nothing is drawn, the originally passed x-coordinate is returned

 */

{

	DrawPixelInfo *dpi = _cur_dpi;

	FontSize size = _cur_fontsize;

	WChar c;

	int xo = x, yo = y;

	if (!parse_string_also_when_clipped) {

		/* in "mode multiline", the available space have been verified. Not in regular one.

		if (colour != TC_INVALID) { // the invalid colour flag test should not  really occur.  But better be safe

switch_colour:;

			} else {

			}

		}

	}

			goto check_bounds;

		} else if (c >= SCC_BLUE && c <= SCC_BLACK) { // change colour?

			previous_colour = colour;

			goto switch_colour;

		} else if (c == SCC_PREVIOUS_COLOUR) { // revert to the previous colour

			Swap(colour, previous_colour);

 * @param str  Character buffer containing the string

 * @param x    Left-most x coordinate to start drawing

 * @param y    Y coordinate to draw the string

 * @param maxw  Maximal width in pixels that may be used for drawing

 *

 * @return Right-most x position after drawing the (possibly truncated) string

 */

{

	char buffer[DRAW_STRING_BUFFER];

	strecpy(buffer, str, lastof(buffer));

	TruncateString(buffer, maxw);

}

/**

void DrawSprite(SpriteID img, SpriteID pal, int x, int y, const SubSprite *sub)

{

	if (HasBit(img, PALETTE_MODIFIER_TRANSPARENT)) {

		GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH), ST_NORMAL), x, y, BM_TRANSPARENT, sub);

	} else if (pal != PAL_NONE) {

		GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH), ST_NORMAL), x, y, BM_COLOUR_REMAP, sub);

	} else {

		GfxMainBlitter(GetSprite(GB(img, 0, SPRITE_WIDTH), ST_NORMAL), x, y, BM_NORMAL, sub);

	bp.dst = dpi->dst_ptr;

	bp.pitch = dpi->pitch;

	assert(sprite->width > 0);

	assert(sprite->height > 0);

void DrawSprite(SpriteID img, SpriteID pal, int x, int y, const SubSprite *sub = NULL);

void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3);

Dimension GetStringBoundingBox(const char *str);

	TC_DARK_BLUE   = 0x0F,

	TC_BLACK       = 0x10,

	TC_INVALID     = 0xFF,

};

/** Defines a few values that are related to animations using palette changes */

enum PaletteAnimationSizes {

	PALETTE_ANIM_SIZE_START = 217,  ///< Index in  the _palettes array from which all animations are taking places (table/palettes.h)

};

/** Define the operation GfxFillRect performs */

enum FillRectMode {

	FILLRECT_OPAQUE,  ///< Fill rectangle with a single color

// This puts a text-message to the console, or in the future, the chat-box,

//  (to keep it all a bit more general)

// If 'self_send' is true, this is the client who is sending the message

{

	const int duration = 10; // Game days the messages stay visible

			if (data >= NETWORK_SERVER_MESSAGE_END) return;

			strid = STR_NETWORK_SERVER_MESSAGE;

			data = STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED_PLAYERS + data;

			break;

		case NETWORK_ACTION_COMPANY_SPECTATOR:

			strid = STR_NETWORK_CLIENT_COMPANY_SPECTATE;

			break;

		case NETWORK_ACTION_COMPANY_JOIN:

			strid = STR_NETWORK_CLIENT_COMPANY_JOIN;

			break;

		case NETWORK_ACTION_COMPANY_NEW:

			strid = STR_NETWORK_CLIENT_COMPANY_NEW;

			break;

		case NETWORK_ACTION_JOIN:           strid = STR_NETWORK_CLIENT_JOINED; break;

	GetString(message, strid, lastof(message));

	DEBUG(desync, 1, "msg: %d; %d; %s\n", _date, _date_fract, message);

}

// Calculate the frame-lag of a client

struct ChatMessage {

	char message[DRAW_STRING_BUFFER];

	Date end_date;

};

 * @param duration The duration of the chat message in game-days

 * @param message message itself in printf() style

 */

{

	char buf[DRAW_STRING_BUFFER];

	const char *bufp;

		/* The default colour for a message is company colour. Replace this with

		 * white for any additional lines */

		cmsg->end_date = _date + duration;

		bufp += strlen(bufp) + 1; // jump to 'next line' in the formatted string

	/* Paint the chat messages starting with the lowest at the bottom */

	for (uint y = NETWORK_CHAT_LINE_HEIGHT; count-- != 0; y += NETWORK_CHAT_LINE_HEIGHT) {

	}

	/* Make sure the data is updated next flush */

#include "core/address.h"

#include "network_type.h"

#include "../console_type.h"

extern NetworkServerGameInfo _network_game_info;

extern NetworkCompanyState *_network_company_states;

void NetworkServerSendChat(NetworkAction action, DestType type, int dest, const char *msg, ClientID from_id, int64 data = 0);

void NetworkInitChatMessage();

void NetworkUndrawChatMessage();

void NetworkChatMessageDailyLoop();

 * Draw an unformatted news message truncated to a maximum length. If

 * length exceeds maximum length it will be postfixed by '...'

 * @param x,y position of the string

 * @param *ni NewsItem being printed

 * @param maxw maximum width of string in pixels

 */

{

	char buffer[512], buffer2[512];

	StringID str;

	*dest = '\0';

	/* Truncate and show string; postfixed by '...' if neccessary */

}

	byte shadow;

};

	{ /* DOS palette. */

		{ 150,   1 }, // TC_BLUE

		{  12,   1 }, // TC_SILVER

		SetDParam(0, company);

		SetDParam(1, company);

		if (this->greyed) {

			col = TC_GREY;

		} else {

		if (_settings_game.economy.station_noise_level) {

			SetDParam(0, this->town->noise_reached);

			SetDParam(1, this->town->MaxTownNoise());