1

/* $Id$ */

     2

     3

/** @file texteff.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "macros.h"

     9

#include "strings.h"

    10

#include "gfx.h"

    11

#include "landscape.h"

    12

#include "viewport.h"

    13

#include "saveload.h"

    14

#include "console.h"

    15

#include "string.h"

    16

#include "variables.h"

    17

#include "table/sprites.h"

    18

#include "blitter/factory.hpp"

    19

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

    20

#include "date.h"

    21

#include "texteff.hpp"

    22

#include "video/video_driver.hpp"

    23

    24

enum {

    25

	MAX_TEXTMESSAGE_LENGTH = 200,

    26

	INIT_NUM_TEXT_MESSAGES =  20,

    27

	MAX_CHAT_MESSAGES      =  10,

    28

	MAX_ANIMATED_TILES     = 256,

    29

};

    30

    31

struct TextEffect {

    32

	StringID string_id;

    33

	int32 x;

    34

	int32 y;

    35

	int32 right;

    36

	int32 bottom;

    37

	uint16 duration;

    38

	uint64 params_1;

    39

	uint64 params_2;

    40

	TextEffectMode mode;

    41

};

    42

    43

    44

struct ChatMessage {

    45

	char message[MAX_TEXTMESSAGE_LENGTH];

    46

	uint16 color;

    47

	Date end_date;

    48

};

    49

    50

/* used for text effects */

    51

static TextEffect *_text_effect_list = NULL;

    52

static uint16 _num_text_effects = INIT_NUM_TEXT_MESSAGES;

    53

TileIndex _animated_tile_list[MAX_ANIMATED_TILES];

    54

    55

/* used for chat window */

    56

static ChatMessage _chatmsg_list[MAX_CHAT_MESSAGES];

    57

static bool _chatmessage_dirty = false;

    58

static bool _chatmessage_visible = false;

    59

    60

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

    61

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

    62

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

    63

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

    64

    65

static inline uint GetChatMessageCount()

    66

{

    67

	uint i;

    68

    69

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

    70

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

    71

	}

    72

    73

	return i;

    74

}

    75

    76

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

    77

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

    78

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

    79

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

    80

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

    81

{

    82

	char buf[MAX_TEXTMESSAGE_LENGTH];

    83

	const char *bufp;

    84

	va_list va;

    85

	uint msg_count;

    86

	uint16 lines;

    87

    88

	va_start(va, message);

    89

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

    90

	va_end(va);

    91

    92

    93

	Utf8TrimString(buf, MAX_TEXTMESSAGE_LENGTH);

    94

    95

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

    96

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

    97

	if (lines >= MAX_CHAT_MESSAGES) return;

    98

    99

	msg_count = GetChatMessageCount();

   100

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

   101

	if (lines > MAX_CHAT_MESSAGES - msg_count) {

   102

		int i = lines - (MAX_CHAT_MESSAGES - msg_count);

   103

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

   104

		msg_count = MAX_CHAT_MESSAGES - lines;

   105

	}

   106

   107

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

   108

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

   109

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

   110

   111

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

   112

		 * white for any additional lines */

   113

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

   114

		cmsg->end_date = _date + duration;

   115

   116

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

   117

	}

   118

   119

	_chatmessage_dirty = true;

   120

}

   121

   122

void InitChatMessage()

   123

{

   124

	uint i;

   125

   126

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

   127

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

   128

	}

   129

}

   130

   131

/** Hide the chatbox */

   132

void UndrawChatMessage()

   133

{

   134

	if (_chatmessage_visible) {

   135

		Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   136

		/* Sometimes we also need to hide the cursor

   137

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

   138

		 *   screen before drawing.

   139

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

   140

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

   141

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

   142

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

   143

		 *   looks nicely ;)

   144

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

   145

		 */

   146

   147

		if (_cursor.visible) {

   148

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

   149

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

   150

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

   151

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

   152

				UndrawMouseCursor();

   153

			}

   154

		}

   155

   156

		int x      = _chatmsg_box.x;

   157

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

   158

		int width  = _chatmsg_box.width;

   159

		int height = _chatmsg_box.height;

   160

		if (y < 0) {

   161

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

   162

			y = 0;

   163

		}

   164

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

   165

			width = _screen.width - x;

   166

		}

   167

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

   168

   169

		_chatmessage_visible = false;

   170

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

   171

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

   172

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

   173

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

   174

   175

		_chatmessage_dirty = true;

   176

	}

   177

}

   178

   179

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

   180

void ChatMessageDailyLoop()

   181

{

   182

	uint i;

   183

   184

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

   185

		ChatMessage *cmsg = &_chatmsg_list[i];

   186

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

   187

   188

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

   189

		if (cmsg->end_date < _date) {

   190

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

   191

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

   192

   193

			/* Mark the last item as empty */

   194

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

   195

			_chatmessage_dirty = true;

   196

   197

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

   198

			i--;

   199

		}

   200

	}

   201

}

   202

   203

/** Draw the chat message-box */

   204

void DrawChatMessage()

   205

{

   206

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   207

	if (!_chatmessage_dirty) return;

   208

   209

	/* First undraw if needed */

   210

	UndrawChatMessage();

   211

   212

	if (_iconsole_mode == ICONSOLE_FULL) return;

   213

   214

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

   215

	uint count = GetChatMessageCount();

   216

	if (count == 0) return;

   217

   218

	int x      = _chatmsg_box.x;

   219

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

   220

	int width  = _chatmsg_box.width;

   221

	int height = _chatmsg_box.height;

   222

	if (y < 0) {

   223

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

   224

		y = 0;

   225

	}

   226

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

   227

		width = _screen.width - x;

   228

	}

   229

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

   230

   231

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

   232

   233

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

   234

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

   235

   236

	_cur_dpi = &_screen; // switch to _screen painting

   237

   238

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

   239

	GfxFillRect(

   240

			_chatmsg_box.x,

   241

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

   242

			_chatmsg_box.x + _chatmsg_box.width - 1,

   243

			_screen.height - _chatmsg_box.y - 2,

   244

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

   245

		);

   246

   247

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

   248

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

   249

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

   250

	}

   251

   252

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

   253

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

   254

   255

	_chatmessage_visible = true;

   256

	_chatmessage_dirty = false;

   257

}

   258

   259

/** Text Effects */

   260

static void MarkTextEffectAreaDirty(TextEffect *te)

   261

{

   262

	MarkAllViewportsDirty(

   263

		te->x,

   264

		te->y - 1,

   265

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

   266

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

   267

	);

   268

}

   269

   270

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

   271

{

   272

	TextEffect *te;

   273

	int w;

   274

	char buffer[100];

   275

	TextEffectID i;

   276

   277

	if (_game_mode == GM_MENU) return INVALID_TE_ID;

   278

   279

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

   280

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

   281

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

   282

	}

   283

   284

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

   285

	if (i == _num_text_effects) {

   286

		_num_text_effects += 25;

   287

		_text_effect_list = (TextEffect*) realloc(_text_effect_list, _num_text_effects * sizeof(TextEffect));

   288

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

   289

		i = _num_text_effects - 1;

   290

	}

   291

   292

	te = &_text_effect_list[i];

   293

   294

	/* Start defining this object */

   295

	te->string_id = msg;

   296

	te->duration = duration;

   297

	te->y = y - 5;

   298

	te->bottom = y + 5;

   299

	te->params_1 = GetDParam(0);

   300

	te->params_2 = GetDParam(4);

   301

	te->mode = mode;

   302

   303

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

   304

	w = GetStringBoundingBox(buffer).width;

   305

   306

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

   307

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

   308

	MarkTextEffectAreaDirty(te);

   309

   310

	return i;

   311

}

   312

   313

void UpdateTextEffect(TextEffectID te_id, StringID msg)

   314

{

   315

	assert(te_id < _num_text_effects);

   316

	TextEffect *te;

   317

   318

	/* Update details */

   319

	te = &_text_effect_list[te_id];

   320

	te->string_id = msg;

   321

	te->params_1 = GetDParam(0);

   322

	te->params_2 = GetDParam(4);

   323

   324

	MarkTextEffectAreaDirty(te);

   325

}

   326

   327

void RemoveTextEffect(TextEffectID te_id)

   328

{

   329

	assert(te_id < _num_text_effects);

   330

	TextEffect *te;

   331

   332

	te = &_text_effect_list[te_id];

   333

	MarkTextEffectAreaDirty(te);

   334

	te->string_id = INVALID_STRING_ID;

   335

}

   336

   337

static void MoveTextEffect(TextEffect *te)

   338

{

   339

	/* Never expire for duration of 0xFFFF */

   340

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

   341

	if (te->duration < 8) {

   342

		te->string_id = INVALID_STRING_ID;

   343

	} else {

   344

		te->duration -= 8;

   345

		te->y--;

   346

		te->bottom--;

   347

	}

   348

	MarkTextEffectAreaDirty(te);

   349

}

   350

   351

void MoveAllTextEffects()

   352

{

   353

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

   354

		TextEffect *te = &_text_effect_list[i];

   355

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

   356

	}

   357

}

   358

   359

void InitTextEffects()

   360

{

   361

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

   362

   363

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

   364

}

   365

   366

void DrawTextEffects(DrawPixelInfo *dpi)

   367

{

   368

	switch (dpi->zoom) {

   369

		case ZOOM_LVL_NORMAL:

   370

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

   371

				TextEffect *te = &_text_effect_list[i];

   372

				if (te->string_id != INVALID_STRING_ID &&

   373

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

   374

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

   375

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

   376

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

   377

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

   378

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

   379

					}

   380

				}

   381

			}

   382

			break;

   383

   384

		case ZOOM_LVL_OUT_2X:

   385

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

   386

				TextEffect *te = &_text_effect_list[i];

   387

				if (te->string_id != INVALID_STRING_ID &&

   388

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

   389

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

   390

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

   391

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

   392

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

   393

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

   394

					}

   395

				}

   396

			}

   397

			break;

   398

   399

		case ZOOM_LVL_OUT_4X:

   400

		case ZOOM_LVL_OUT_8X:

   401

			break;

   402

   403

		default: NOT_REACHED();

   404

	}

   405

}

   406

   407

void DeleteAnimatedTile(TileIndex tile)

   408

{

   409

	TileIndex *ti;

   410

   411

	for (ti = _animated_tile_list; ti != endof(_animated_tile_list); ti++) {

   412

		if (tile == *ti) {

   413

			/* remove the hole */

   414

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

   415

			/* and clear last item */

   416

			*lastof(_animated_tile_list) = 0;

   417

			MarkTileDirtyByTile(tile);

   418

			return;

   419

		}

   420

	}

   421

}

   422

   423

bool AddAnimatedTile(TileIndex tile)

   424

{

   425

	TileIndex *ti;

   426

   427

	for (ti = _animated_tile_list; ti != endof(_animated_tile_list); ti++) {

   428

		if (tile == *ti || *ti == 0) {

   429

			*ti = tile;

   430

			MarkTileDirtyByTile(tile);

   431

			return true;

   432

		}

   433

	}

   434

   435

	return false;

   436

}

   437

   438

void AnimateAnimatedTiles()

   439

{

   440

	const TileIndex* ti;

   441

   442

	for (ti = _animated_tile_list; ti != endof(_animated_tile_list) && *ti != 0; ti++) {

   443

		AnimateTile(*ti);

   444

	}

   445

}

   446

   447

void InitializeAnimatedTiles()

   448

{

   449

	memset(_animated_tile_list, 0, sizeof(_animated_tile_list));

   450

}

   451

   452

static void SaveLoad_ANIT()

   453

{

   454

	/* In pre version 6, we has 16bit per tile, now we have 32bit per tile, convert it ;) */

   455

	if (CheckSavegameVersion(6)) {

   456

		SlArray(_animated_tile_list, lengthof(_animated_tile_list), SLE_FILE_U16 | SLE_VAR_U32);

   457

	} else {

   458

		SlArray(_animated_tile_list, lengthof(_animated_tile_list), SLE_UINT32);

   459

	}

   460

}

   461

   462

   463

extern const ChunkHandler _animated_tile_chunk_handlers[] = {

   464

	{ 'ANIT', SaveLoad_ANIT, SaveLoad_ANIT, CH_RIFF | CH_LAST},

   465

};