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 "hal.h"

    15

#include "console.h"

    16

#include "string.h"

    17

#include "variables.h"

    18

#include "table/sprites.h"

    19

#include "blitter/factory.hpp"

    20

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

    21

#include "date.h"

    23

    24

enum {

    25

	MAX_TEXTMESSAGE_LENGTH = 200,

    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

	uint32 params_1;

    39

	uint32 params_2;

    41

};

    42

    43

    44

struct TextMessage {

    45

	char message[MAX_TEXTMESSAGE_LENGTH];

    46

	uint16 color;

    47

	Date end_date;

    48

};

    49

    51

static TextMessage _textmsg_list[MAX_CHAT_MESSAGES];

    52

TileIndex _animated_tile_list[MAX_ANIMATED_TILES];

    53

    54

static bool _textmessage_dirty = false;

    55

static bool _textmessage_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 Oblong _textmsg_box = {10, 30, 500, 150};

    61

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

    62

    63

static inline uint GetTextMessageCount()

    64

{

    65

	uint i;

    66

    67

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

    68

		if (_textmsg_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 AddTextMessage(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, _textmsg_box.width - 8), 0, 16) + 1;

    95

	if (lines >= MAX_CHAT_MESSAGES) return;

    96

    97

	msg_count = GetTextMessageCount();

    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(&_textmsg_list[0], &_textmsg_list[i], sizeof(_textmsg_list[0]) * (msg_count - i));

   102

		msg_count = MAX_CHAT_MESSAGES - lines;

   103

	}

   104

   105

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

   106

		TextMessage *tmsg = &_textmsg_list[msg_count++];

   107

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

   108

   109

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

   110

		 * white for any additional lines */

   111

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

   112

		tmsg->end_date = _date + duration;

   113

   114

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

   115

	}

   116

   117

	_textmessage_dirty = true;

   118

}

   119

   120

void InitTextMessage()

   121

{

   122

	uint i;

   123

   124

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

   125

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

   126

	}

   127

}

   128

   129

/** Hide the textbox */

   130

void UndrawTextMessage()

   131

{

   132

	if (_textmessage_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 >= _textmsg_box.x &&

   147

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

   148

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

   149

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

   150

				UndrawMouseCursor();

   151

			}

   152

		}

   153

   154

		int x      = _textmsg_box.x;

   155

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

   156

		int width  = _textmsg_box.width;

   157

		int height = _textmsg_box.height;

   158

		if (y < 0) {

   159

			height = max(height + y, min(_textmsg_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

		_textmessage_visible = false;

   168

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

   169

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

   170

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

   171

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

   172

   173

		_textmessage_dirty = true;

   174

	}

   175

}

   176

   177

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

   178

void TextMessageDailyLoop()

   179

{

   180

	uint i;

   181

   182

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

   183

		TextMessage *tmsg = &_textmsg_list[i];

   184

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

   185

   186

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

   187

		if (tmsg->end_date < _date) {

   188

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

   189

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

   190

   191

			/* Mark the last item as empty */

   192

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

   193

			_textmessage_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 textmessage-box */

   202

void DrawTextMessage()

   203

{

   204

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   205

	if (!_textmessage_dirty) return;

   206

   207

	/* First undraw if needed */

   208

	UndrawTextMessage();

   209

   210

	if (_iconsole_mode == ICONSOLE_FULL) return;

   211

   212

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

   213

	uint count = GetTextMessageCount();

   214

	if (count == 0) return;

   215

   216

	int x      = _textmsg_box.x;

   217

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

   218

	int width  = _textmsg_box.width;

   219

	int height = _textmsg_box.height;

   220

	if (y < 0) {

   221

		height = max(height + y, min(_textmsg_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(_textmessage_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), _textmessage_backup, width, height);

   233

   234

	_cur_dpi = &_screen; // switch to _screen painting

   235

   236

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

   237

	GfxFillRect(

   238

			_textmsg_box.x,

   239

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

   240

			_textmsg_box.x + _textmsg_box.width - 1,

   241

			_screen.height - _textmsg_box.y - 2,

   242

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

   243

		);

   244

   245

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

   246

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

   247

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

   248

	}

   249

   250

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

   251

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

   252

   253

	_textmessage_visible = true;

   254

	_textmessage_dirty = false;

   255

}

   256

   257

static void MarkTextEffectAreaDirty(TextEffect *te)

   258

{

   259

	MarkAllViewportsDirty(

   260

		te->x,

   261

		te->y - 1,

   262

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

   263

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

   264

	);

   265

}

   266

   268

{

   269

	TextEffect *te;

   270

	int w;

   271

	char buffer[100];

   273

   275

   279

	}

   280

   292

	te->string_id = msg;

   293

	te->duration = duration;

   294

	te->y = y - 5;

   295

	te->bottom = y + 5;

   296

	te->params_1 = GetDParam(0);

   297

	te->params_2 = GetDParam(4);

   299

   300

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

   301

	w = GetStringBoundingBox(buffer).width;

   302

   303

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

   304

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

   305

	MarkTextEffectAreaDirty(te);

   332

}

   333

   334

static void MoveTextEffect(TextEffect *te)

   335

{

   338

	if (te->duration < 8) {

   339

		te->string_id = INVALID_STRING_ID;

   340

	} else {

   341

		te->duration -= 8;

   342

		te->y--;

   343

		te->bottom--;

   344

	}

   345

	MarkTextEffectAreaDirty(te);

   346

}

   347

   348

void MoveAllTextEffects()

   349

{

   353

	}

   354

}

   355

   356

void InitTextEffects()

   357

{

   359

   361

}

   362

   363

void DrawTextEffects(DrawPixelInfo *dpi)

   364

{

   365

	switch (dpi->zoom) {

   366

		case ZOOM_LVL_NORMAL:

   369

				if (te->string_id != INVALID_STRING_ID &&

   370

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

   371

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

   372

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

   373

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

   377

				}

   378

			}

   379

			break;

   380

   381

		case ZOOM_LVL_OUT_2X:

   384

				if (te->string_id != INVALID_STRING_ID &&

   385

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

   386

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

   387

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

   388

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

   392

				}

   393

			}

   394

			break;

   395

   396

		case ZOOM_LVL_OUT_4X:

   397

		case ZOOM_LVL_OUT_8X:

   398

			break;

   399

   400

		default: NOT_REACHED();

   401

	}

   402

}

   403

   404

void DeleteAnimatedTile(TileIndex tile)

   405

{

   406

	TileIndex *ti;

   407

   408

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

   409

		if (tile == *ti) {

   410

			/* remove the hole */

   411

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

   412

			/* and clear last item */

   413

			*lastof(_animated_tile_list) = 0;

   414

			MarkTileDirtyByTile(tile);

   415

			return;

   416

		}

   417

	}

   418

}

   419

   420

bool AddAnimatedTile(TileIndex tile)

   421

{

   422

	TileIndex *ti;

   423

   424

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

   425

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

   426

			*ti = tile;

   427

			MarkTileDirtyByTile(tile);

   428

			return true;

   429

		}

   430

	}

   431

   432

	return false;

   433

}

   434

   435

void AnimateAnimatedTiles()

   436

{

   437

	const TileIndex* ti;

   438

   439

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

   440

		AnimateTile(*ti);

   441

	}

   442

}

   443

   444

void InitializeAnimatedTiles()

   445

{

   446

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

   447

}

   448

   449

static void SaveLoad_ANIT()

   450

{

   451

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

   452

	if (CheckSavegameVersion(6)) {

   453

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

   454

	} else {

   455

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

   456

	}

   457

}

   458

   459

   460

extern const ChunkHandler _animated_tile_chunk_handlers[] = {

   461

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

   462

};