1

/* $Id$ */

     2

     3

/** @file texteff.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "tile_cmd.h"

     8

#include "landscape.h"

     9

#include "viewport.h"

    10

#include "saveload.h"

    11

#include "console.h"

    12

#include "variables.h"

    13

#include "table/sprites.h"

    14

#include "blitter/factory.hpp"

    15

#include <stdarg.h> /* va_list */

    16

#include "texteff.hpp"

    17

#include "video/video_driver.hpp"

    18

#include "transparency.h"

    19

#include "strings_func.h"

    20

#include "core/alloc_func.hpp"

    21

#include "date_func.h"

    22

#include "functions.h"

    23

    24

enum {

    25

	MAX_TEXTMESSAGE_LENGTH = 200,

    26

	INIT_NUM_TEXT_MESSAGES =  20,

    27

	MAX_CHAT_MESSAGES      =  10,

    28

};

    29

    30

struct TextEffect {

    31

	StringID string_id;

    32

	int32 x;

    33

	int32 y;

    34

	int32 right;

    35

	int32 bottom;

    36

	uint16 duration;

    37

	uint64 params_1;

    38

	uint64 params_2;

    39

	TextEffectMode mode;

    40

};

    41

    42

    43

struct ChatMessage {

    44

	char message[MAX_TEXTMESSAGE_LENGTH];

    45

	uint16 color;

    46

	Date end_date;

    47

};

    48

    49

/* used for text effects */

    50

static TextEffect *_text_effect_list = NULL;

    51

static uint16 _num_text_effects = INIT_NUM_TEXT_MESSAGES;

    52

    53

/* used for chat window */

    54

static ChatMessage _chatmsg_list[MAX_CHAT_MESSAGES];

    55

static bool _chatmessage_dirty = false;

    56

static bool _chatmessage_visible = false;

    57

    58

/* The chatbox grows from the bottom so the coordinates are pixels from

    59

 * the left and pixels from the bottom. The height is the maximum height */

    60

static const PointDimension _chatmsg_box = {10, 30, 500, 150};

    61

static uint8 _chatmessage_backup[150 * 500 * 6]; // (height * width)

    62

    63

static inline uint GetChatMessageCount()

    64

{

    65

	uint i;

    66

    67

	for (i = 0; i < MAX_CHAT_MESSAGES; i++) {

    68

		if (_chatmsg_list[i].message[0] == '\0') break;

    69

	}

    70

    71

	return i;

    72

}

    73

    74

/* Add a text message to the 'chat window' to be shown

    75

 * @param color The colour this message is to be shown in

    76

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

    77

 * @param message message itself in printf() style */

    78

void CDECL AddChatMessage(uint16 color, uint8 duration, const char *message, ...)

    79

{

    80

	char buf[MAX_TEXTMESSAGE_LENGTH];

    81

	const char *bufp;

    82

	va_list va;

    83

	uint msg_count;

    84

	uint16 lines;

    85

    86

	va_start(va, message);

    87

	vsnprintf(buf, lengthof(buf), message, va);

    88

	va_end(va);

    89

    90

    91

	Utf8TrimString(buf, MAX_TEXTMESSAGE_LENGTH);

    92

    93

	/* Force linebreaks for strings that are too long */

    94

	lines = GB(FormatStringLinebreaks(buf, _chatmsg_box.width - 8), 0, 16) + 1;

    95

	if (lines >= MAX_CHAT_MESSAGES) return;

    96

    97

	msg_count = GetChatMessageCount();

    98

	/* We want to add more chat messages than there is free space for, remove 'old' */

    99

	if (lines > MAX_CHAT_MESSAGES - msg_count) {

   100

		int i = lines - (MAX_CHAT_MESSAGES - msg_count);

   101

		memmove(&_chatmsg_list[0], &_chatmsg_list[i], sizeof(_chatmsg_list[0]) * (msg_count - i));

   102

		msg_count = MAX_CHAT_MESSAGES - lines;

   103

	}

   104

   105

	for (bufp = buf; lines != 0; lines--) {

   106

		ChatMessage *cmsg = &_chatmsg_list[msg_count++];

   107

		ttd_strlcpy(cmsg->message, bufp, sizeof(cmsg->message));

   108

   109

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

   110

		 * white for any additional lines */

   111

		cmsg->color = (bufp == buf && color & IS_PALETTE_COLOR) ? color : (0x1D - 15) | IS_PALETTE_COLOR;

   112

		cmsg->end_date = _date + duration;

   113

   114

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

   115

	}

   116

   117

	_chatmessage_dirty = true;

   118

}

   119

   120

void InitChatMessage()

   121

{

   122

	uint i;

   123

   124

	for (i = 0; i < MAX_CHAT_MESSAGES; i++) {

   125

		_chatmsg_list[i].message[0] = '\0';

   126

	}

   127

}

   128

   129

/** Hide the chatbox */

   130

void UndrawChatMessage()

   131

{

   132

	if (_chatmessage_visible) {

   133

		Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   134

		/* Sometimes we also need to hide the cursor

   135

		 *   This is because both textmessage and the cursor take a shot of the

   136

		 *   screen before drawing.

   137

		 *   Now the textmessage takes his shot and paints his data before the cursor

   138

		 *   does, so in the shot of the cursor is the screen-data of the textmessage

   139

		 *   included when the cursor hangs somewhere over the textmessage. To

   140

		 *   avoid wrong repaints, we undraw the cursor in that case, and everything

   141

		 *   looks nicely ;)

   142

		 * (and now hope this story above makes sense to you ;))

   143

		 */

   144

   145

		if (_cursor.visible) {

   146

			if (_cursor.draw_pos.x + _cursor.draw_size.x >= _chatmsg_box.x &&

   147

				_cursor.draw_pos.x <= _chatmsg_box.x + _chatmsg_box.width &&

   148

				_cursor.draw_pos.y + _cursor.draw_size.y >= _screen.height - _chatmsg_box.y - _chatmsg_box.height &&

   149

				_cursor.draw_pos.y <= _screen.height - _chatmsg_box.y) {

   150

				UndrawMouseCursor();

   151

			}

   152

		}

   153

   154

		int x      = _chatmsg_box.x;

   155

		int y      = _screen.height - _chatmsg_box.y - _chatmsg_box.height;

   156

		int width  = _chatmsg_box.width;

   157

		int height = _chatmsg_box.height;

   158

		if (y < 0) {

   159

			height = max(height + y, min(_chatmsg_box.height, _screen.height));

   160

			y = 0;

   161

		}

   162

		if (x + width >= _screen.width) {

   163

			width = _screen.width - x;

   164

		}

   165

		if (width <= 0 || height <= 0) return;

   166

   167

		_chatmessage_visible = false;

   168

		/* Put our 'shot' back to the screen */

   169

		blitter->CopyFromBuffer(blitter->MoveTo(_screen.dst_ptr, x, y), _chatmessage_backup, width, height);

   170

		/* And make sure it is updated next time */

   171

		_video_driver->MakeDirty(x, y, width, height);

   172

   173

		_chatmessage_dirty = true;

   174

	}

   175

}

   176

   177

/** Check if a message is expired every day */

   178

void ChatMessageDailyLoop()

   179

{

   180

	uint i;

   181

   182

	for (i = 0; i < MAX_CHAT_MESSAGES; i++) {

   183

		ChatMessage *cmsg = &_chatmsg_list[i];

   184

		if (cmsg->message[0] == '\0') continue;

   185

   186

		/* Message has expired, remove from the list */

   187

		if (cmsg->end_date < _date) {

   188

			/* Move the remaining messages over the current message */

   189

			if (i != MAX_CHAT_MESSAGES - 1) memmove(cmsg, cmsg + 1, sizeof(*cmsg) * (MAX_CHAT_MESSAGES - i - 1));

   190

   191

			/* Mark the last item as empty */

   192

			_chatmsg_list[MAX_CHAT_MESSAGES - 1].message[0] = '\0';

   193

			_chatmessage_dirty = true;

   194

   195

			/* Go one item back, because we moved the array 1 to the left */

   196

			i--;

   197

		}

   198

	}

   199

}

   200

   201

/** Draw the chat message-box */

   202

void DrawChatMessage()

   203

{

   204

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   205

	if (!_chatmessage_dirty) return;

   206

   207

	/* First undraw if needed */

   208

	UndrawChatMessage();

   209

   210

	if (_iconsole_mode == ICONSOLE_FULL) return;

   211

   212

	/* Check if we have anything to draw at all */

   213

	uint count = GetChatMessageCount();

   214

	if (count == 0) return;

   215

   216

	int x      = _chatmsg_box.x;

   217

	int y      = _screen.height - _chatmsg_box.y - _chatmsg_box.height;

   218

	int width  = _chatmsg_box.width;

   219

	int height = _chatmsg_box.height;

   220

	if (y < 0) {

   221

		height = max(height + y, min(_chatmsg_box.height, _screen.height));

   222

		y = 0;

   223

	}

   224

	if (x + width >= _screen.width) {

   225

		width = _screen.width - x;

   226

	}

   227

	if (width <= 0 || height <= 0) return;

   228

   229

	assert(blitter->BufferSize(width, height) < (int)sizeof(_chatmessage_backup));

   230

   231

	/* Make a copy of the screen as it is before painting (for undraw) */

   232

	blitter->CopyToBuffer(blitter->MoveTo(_screen.dst_ptr, x, y), _chatmessage_backup, width, height);

   233

   234

	_cur_dpi = &_screen; // switch to _screen painting

   235

   236

	/* Paint a half-transparent box behind the chat messages */

   237

	GfxFillRect(

   238

			_chatmsg_box.x,

   239

			_screen.height - _chatmsg_box.y - count * 13 - 2,

   240

			_chatmsg_box.x + _chatmsg_box.width - 1,

   241

			_screen.height - _chatmsg_box.y - 2,

   242

			PALETTE_TO_TRANSPARENT | (1 << USE_COLORTABLE) // black, but with some alpha for background

   243

		);

   244

   245

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

   246

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

   247

		DoDrawString(_chatmsg_list[count].message, _chatmsg_box.x + 3, _screen.height - _chatmsg_box.y - y + 1, _chatmsg_list[count].color);

   248

	}

   249

   250

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

   251

	_video_driver->MakeDirty(x, y, width, height);

   252

   253

	_chatmessage_visible = true;

   254

	_chatmessage_dirty = false;

   255

}

   256

   257

/* Text Effects */

   258

/**

   259

 * Mark the area of the text effect as dirty.

   260

 *

   261

 * This function marks the area of a text effect as dirty for repaint.

   262

 *

   263

 * @param te The TextEffect to mark the area dirty

   264

 * @ingroup dirty

   265

 */

   266

static void MarkTextEffectAreaDirty(TextEffect *te)

   267

{

   268

	/* Width and height of the text effect are doubled, so they are correct in both zoom out levels 1x and 2x. */

   269

	MarkAllViewportsDirty(

   270

		te->x,

   271

		te->y - 1,

   272

		(te->right - te->x)*2 + te->x + 1,

   273

		(te->bottom - (te->y - 1)) * 2 + (te->y - 1) + 1

   274

	);

   275

}

   276

   277

TextEffectID AddTextEffect(StringID msg, int x, int y, uint16 duration, TextEffectMode mode)

   278

{

   279

	TextEffect *te;

   280

	int w;

   281

	char buffer[100];

   282

	TextEffectID i;

   283

   284

	if (_game_mode == GM_MENU) return INVALID_TE_ID;

   285

   286

	/* Look for a free spot in the text effect array */

   287

	for (i = 0; i < _num_text_effects; i++) {

   288

		if (_text_effect_list[i].string_id == INVALID_STRING_ID) break;

   289

	}

   290

   291

	/* If there is none found, we grow the array */

   292

	if (i == _num_text_effects) {

   293

		_num_text_effects += 25;

   294

		_text_effect_list = ReallocT<TextEffect>(_text_effect_list, _num_text_effects);

   295

		for (; i < _num_text_effects; i++) _text_effect_list[i].string_id = INVALID_STRING_ID;

   296

		i = _num_text_effects - 1;

   297

	}

   298

   299

	te = &_text_effect_list[i];

   300

   301

	/* Start defining this object */

   302

	te->string_id = msg;

   303

	te->duration = duration;

   304

	te->y = y - 5;

   305

	te->bottom = y + 5;

   306

	te->params_1 = GetDParam(0);

   307

	te->params_2 = GetDParam(4);

   308

	te->mode = mode;

   309

   310

	GetString(buffer, msg, lastof(buffer));

   311

	w = GetStringBoundingBox(buffer).width;

   312

   313

	te->x = x - (w >> 1);

   314

	te->right = x + (w >> 1) - 1;

   315

	MarkTextEffectAreaDirty(te);

   316

   317

	return i;

   318

}

   319

   320

void UpdateTextEffect(TextEffectID te_id, StringID msg)

   321

{

   322

	assert(te_id < _num_text_effects);

   323

	TextEffect *te;

   324

   325

	/* Update details */

   326

	te = &_text_effect_list[te_id];

   327

	te->string_id = msg;

   328

	te->params_1 = GetDParam(0);

   329

	te->params_2 = GetDParam(4);

   330

   331

	/* Update width of text effect */

   332

	char buffer[100];

   333

	GetString(buffer, msg, lastof(buffer));

   334

	int w = GetStringBoundingBox(buffer).width;

   335

   336

	/* Only allow to make it broader, so it completely covers the old text. That avoids remnants of the old text. */

   337

	int right_new = te->x + w;

   338

	if (te->right < right_new) te->right = right_new;

   339

   340

	MarkTextEffectAreaDirty(te);

   341

}

   342

   343

void RemoveTextEffect(TextEffectID te_id)

   344

{

   345

	assert(te_id < _num_text_effects);

   346

	TextEffect *te;

   347

   348

	te = &_text_effect_list[te_id];

   349

	MarkTextEffectAreaDirty(te);

   350

	te->string_id = INVALID_STRING_ID;

   351

}

   352

   353

static void MoveTextEffect(TextEffect *te)

   354

{

   355

	/* Never expire for duration of 0xFFFF */

   356

	if (te->duration == 0xFFFF) return;

   357

	if (te->duration < 8) {

   358

		te->string_id = INVALID_STRING_ID;

   359

	} else {

   360

		te->duration -= 8;

   361

		te->y--;

   362

		te->bottom--;

   363

	}

   364

	MarkTextEffectAreaDirty(te);

   365

}

   366

   367

void MoveAllTextEffects()

   368

{

   369

	for (TextEffectID i = 0; i < _num_text_effects; i++) {

   370

		TextEffect *te = &_text_effect_list[i];

   371

		if (te->string_id != INVALID_STRING_ID && te->mode == TE_RISING) MoveTextEffect(te);

   372

	}

   373

}

   374

   375

void InitTextEffects()

   376

{

   377

	if (_text_effect_list == NULL) _text_effect_list = MallocT<TextEffect>(_num_text_effects);

   378

   379

	for (TextEffectID i = 0; i < _num_text_effects; i++) _text_effect_list[i].string_id = INVALID_STRING_ID;

   380

}

   381

   382

void DrawTextEffects(DrawPixelInfo *dpi)

   383

{

   384

	switch (dpi->zoom) {

   385

		case ZOOM_LVL_NORMAL:

   386

			for (TextEffectID i = 0; i < _num_text_effects; i++) {

   387

				TextEffect *te = &_text_effect_list[i];

   388

				if (te->string_id != INVALID_STRING_ID &&

   389

						dpi->left <= te->right &&

   390

						dpi->top  <= te->bottom &&

   391

						dpi->left + dpi->width  > te->x &&

   392

						dpi->top  + dpi->height > te->y) {

   393

					if (te->mode == TE_RISING || (_patches.loading_indicators && !IsTransparencySet(TO_LOADING))) {

   394

						AddStringToDraw(te->x, te->y, te->string_id, te->params_1, te->params_2);

   395

					}

   396

				}

   397

			}

   398

			break;

   399

   400

		case ZOOM_LVL_OUT_2X:

   401

			for (TextEffectID i = 0; i < _num_text_effects; i++) {

   402

				TextEffect *te = &_text_effect_list[i];

   403

				if (te->string_id != INVALID_STRING_ID &&

   404

						dpi->left <= te->right  * 2 - te->x &&

   405

						dpi->top  <= te->bottom * 2 - te->y &&

   406

						dpi->left + dpi->width  > te->x &&

   407

						dpi->top  + dpi->height > te->y) {

   408

					if (te->mode == TE_RISING || (_patches.loading_indicators && !IsTransparencySet(TO_LOADING))) {

   409

						AddStringToDraw(te->x, te->y, (StringID)(te->string_id - 1), te->params_1, te->params_2);

   410

					}

   411

				}

   412

			}

   413

			break;

   414

   415

		case ZOOM_LVL_OUT_4X:

   416

		case ZOOM_LVL_OUT_8X:

   417

			break;

   418

   419

		default: NOT_REACHED();

   420

	}

   421

}

   422

   423

/** The table/list with animated tiles. */

   424

TileIndex *_animated_tile_list = NULL;

   425

/** The number of animated tiles in the current state. */

   426

uint _animated_tile_count = 0;

   427

/** The number of slots for animated tiles allocated currently. */

   428

static uint _animated_tile_allocated = 0;

   429

   430

/**

   431

 * Removes the given tile from the animated tile table.

   432

 * @param tile the tile to remove

   433

 */

   434

void DeleteAnimatedTile(TileIndex tile)

   435

{

   436

	for (TileIndex *ti = _animated_tile_list; ti < _animated_tile_list + _animated_tile_count; ti++) {

   437

		if (tile == *ti) {

   438

			/* Remove the hole

   439

			 * The order of the remaining elements must stay the same, otherwise the animation loop

   440

			 * may miss a tile; that's why we must use memmove instead of just moving the last element.

   441

			 */

   442

			memmove(ti, ti + 1, (_animated_tile_list + _animated_tile_count - (ti + 1)) * sizeof(*ti));

   443

			_animated_tile_count--;

   444

			MarkTileDirtyByTile(tile);

   445

			return;

   446

		}

   447

	}

   448

}

   449

   450

/**

   451

 * Add the given tile to the animated tile table (if it does not exist

   452

 * on that table yet). Also increases the size of the table if necessary.

   453

 * @param tile the tile to make animated

   454

 */

   455

void AddAnimatedTile(TileIndex tile)

   456

{

   457

	MarkTileDirtyByTile(tile);

   458

   459

	for (const TileIndex *ti = _animated_tile_list; ti < _animated_tile_list + _animated_tile_count; ti++) {

   460

		if (tile == *ti) return;

   461

	}

   462

   463

	/* Table not large enough, so make it larger */

   464

	if (_animated_tile_count == _animated_tile_allocated) {

   465

		_animated_tile_allocated *= 2;

   466

		_animated_tile_list = ReallocT<TileIndex>(_animated_tile_list, _animated_tile_allocated);

   467

	}

   468

   469

	_animated_tile_list[_animated_tile_count] = tile;

   470

	_animated_tile_count++;

   471

}

   472

   473

/**

   474

 * Animate all tiles in the animated tile list, i.e.\ call AnimateTile on them.

   475

 */

   476

void AnimateAnimatedTiles()

   477

{

   478

	const TileIndex *ti = _animated_tile_list;

   479

	while (ti < _animated_tile_list + _animated_tile_count) {

   480

		const TileIndex curr = *ti;

   481

		AnimateTile(curr);

   482

		/* During the AnimateTile call, DeleteAnimatedTile could have been called,

   483

		 * deleting an element we've already processed and pushing the rest one

   484

		 * slot to the left. We can detect this by checking whether the index

   485

		 * in the current slot has changed - if it has, an element has been deleted,