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 <stdarg.h> /* va_list */

    20

#include "date.h"

    21

    22

enum {

    23

	MAX_TEXTMESSAGE_LENGTH = 200,

    24

	MAX_TEXT_MESSAGES      =  30,

    25

	MAX_CHAT_MESSAGES      =  10,

    26

	MAX_ANIMATED_TILES     = 256,

    27

};

    28

    29

struct TextEffect {

    30

	StringID string_id;

    31

	int32 x;

    32

	int32 y;

    33

	int32 right;

    34

	int32 bottom;

    35

	uint16 duration;

    36

	uint32 params_1;

    37

	uint32 params_2;

    38

};

    39

    40

    41

struct TextMessage {

    42

	char message[MAX_TEXTMESSAGE_LENGTH];

    43

	uint16 color;

    44

	Date end_date;

    45

};

    46

    47

static TextEffect _text_effect_list[MAX_TEXT_MESSAGES];

    48

static TextMessage _textmsg_list[MAX_CHAT_MESSAGES];

    49

TileIndex _animated_tile_list[MAX_ANIMATED_TILES];

    50

    51

static bool _textmessage_dirty = false;

    52

static bool _textmessage_visible = false;

    53

    54

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

    55

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

    56

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

    57

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

    58

    59

static inline uint GetTextMessageCount()

    60

{

    61

	uint i;

    62

    63

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

    64

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

    65

	}

    66

    67

	return i;

    68

}

    69

    70

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

    71

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

    72

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

    73

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

    74

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

    75

{

    76

	char buf[MAX_TEXTMESSAGE_LENGTH];

    77

	const char *bufp;

    78

	va_list va;

    79

	uint msg_count;

    80

	uint16 lines;

    81

    82

	va_start(va, message);

    83

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

    84

	va_end(va);

    85

    86

    87

	Utf8TrimString(buf, MAX_TEXTMESSAGE_LENGTH);

    88

    89

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

    90

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

    91

	if (lines >= MAX_CHAT_MESSAGES) return;

    92

    93

	msg_count = GetTextMessageCount();

    94

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

    95

	if (lines > MAX_CHAT_MESSAGES - msg_count) {

    96

		int i = lines - (MAX_CHAT_MESSAGES - msg_count);

    97

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

    98

		msg_count = MAX_CHAT_MESSAGES - lines;

    99

	}

   100

   101

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

   102

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

   103

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

   104

   105

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

   106

		 * white for any additional lines */

   107

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

   108

		tmsg->end_date = _date + duration;

   109

   110

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

   111

	}

   112

   113

	_textmessage_dirty = true;

   114

}

   115

   116

void InitTextMessage()

   117

{

   118

	uint i;

   119

   120

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

   121

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

   122

	}

   123

}

   124

   125

/** Hide the textbox */

   126

void UndrawTextMessage()

   127

{

   128

	if (_textmessage_visible) {

   129

		/* Sometimes we also need to hide the cursor

   130

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

   131

		 *   screen before drawing.

   132

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

   133

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

   134

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

   135

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

   136

		 *   looks nicely ;)

   137

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

   138

		 */

   139

   140

		if (_cursor.visible) {

   141

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

   142

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

   143

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

   144

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

   145

				UndrawMouseCursor();

   146

			}

   147

		}

   148

   149

		int x      = _textmsg_box.x;

   150

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

   151

		int width  = _textmsg_box.width;

   152

		int height = _textmsg_box.height;

   153

		if (y < 0) {

   154

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

   155

			y = 0;

   156

		}

   157

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

   158

			width = _screen.width - x;

   159

		}

   160

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

   161

   162

		_textmessage_visible = false;

   163

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

   164

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

   165

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

   166

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

   167

   168

		_textmessage_dirty = true;

   169

	}

   170

}

   171

   172

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

   173

void TextMessageDailyLoop()

   174

{

   175

	uint i;

   176

   177

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

   178

		TextMessage *tmsg = &_textmsg_list[i];

   179

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

   180

   181

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

   182

		if (tmsg->end_date < _date) {

   183

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

   184

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

   185

   186

			/* Mark the last item as empty */

   187

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

   188

			_textmessage_dirty = true;

   189

   190

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

   191

			i--;

   192

		}

   193

	}

   194

}

   195

   196

/** Draw the textmessage-box */

   197

void DrawTextMessage()

   198

{

   199

	if (!_textmessage_dirty) return;

   200

   201

	/* First undraw if needed */

   202

	UndrawTextMessage();

   203

   204

	if (_iconsole_mode == ICONSOLE_FULL) return;

   205

   206

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

   207

	uint count = GetTextMessageCount();

   208

	if (count == 0) return;

   209

   210

	int x      = _textmsg_box.x;

   211

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

   212

	int width  = _textmsg_box.width;

   213

	int height = _textmsg_box.height;

   214

	if (y < 0) {

   215

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

   216

		y = 0;

   217

	}

   218

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

   219

		width = _screen.width - x;

   220

	}

   221

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

   222

   223

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

   224

	_screen.renderer->CopyToBuffer(_screen.renderer->MoveTo(_screen.dst_ptr, x, y), _textmessage_backup, width, height, _textmsg_box.width);

   225

   226

	_cur_dpi = &_screen; // switch to _screen painting

   227

   228

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

   229

	GfxFillRect(

   230

			_textmsg_box.x,

   231

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

   232

			_textmsg_box.x + _textmsg_box.width - 1,

   233

			_screen.height - _textmsg_box.y - 2,

   234

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

   235

		);

   236

   237

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

   238

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

   239

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

   240

	}

   241

   242

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

   243

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

   244

   245

	_textmessage_visible = true;

   246

	_textmessage_dirty = false;

   247

}

   248

   249

static void MarkTextEffectAreaDirty(TextEffect *te)

   250

{

   251

	MarkAllViewportsDirty(

   252

		te->x,

   253

		te->y - 1,

   254

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

   255

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

   256

	);

   257

}

   258

   259

void AddTextEffect(StringID msg, int x, int y, uint16 duration)

   260

{

   261

	TextEffect *te;

   262

	int w;

   263

	char buffer[100];

   264

   265

	if (_game_mode == GM_MENU) return;

   266

   267

	for (te = _text_effect_list; te->string_id != INVALID_STRING_ID; ) {

   268

		if (++te == endof(_text_effect_list)) return;

   269

	}

   270

   271

	te->string_id = msg;

   272

	te->duration = duration;

   273

	te->y = y - 5;

   274

	te->bottom = y + 5;

   275

	te->params_1 = GetDParam(0);

   276

	te->params_2 = GetDParam(4);

   277

   278

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

   279

	w = GetStringBoundingBox(buffer).width;

   280

   281

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

   282

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

   283

	MarkTextEffectAreaDirty(te);

   284

}

   285

   286

static void MoveTextEffect(TextEffect *te)

   287

{

   288

	if (te->duration < 8) {

   289

		te->string_id = INVALID_STRING_ID;

   290

	} else {

   291

		te->duration -= 8;

   292

		te->y--;

   293

		te->bottom--;

   294

	}

   295

	MarkTextEffectAreaDirty(te);

   296

}

   297

   298

void MoveAllTextEffects()

   299

{

   300

	TextEffect *te;

   301

   302

	for (te = _text_effect_list; te != endof(_text_effect_list); te++) {

   303

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

   304

	}

   305

}

   306

   307

void InitTextEffects()

   308

{

   309

	TextEffect *te;

   310

   311

	for (te = _text_effect_list; te != endof(_text_effect_list); te++) {

   312

		te->string_id = INVALID_STRING_ID;

   313

	}

   314

}

   315

   316

void DrawTextEffects(DrawPixelInfo *dpi)

   317

{

   318

	const TextEffect* te;

   319

   320

	switch (dpi->zoom) {

   321

		case ZOOM_LVL_NORMAL:

   322

			for (te = _text_effect_list; te != endof(_text_effect_list); te++) {

   323

				if (te->string_id != INVALID_STRING_ID &&

   324

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

   325

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

   326

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

   327

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

   328

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

   329

				}

   330

			}

   331

			break;

   332

   333

		case ZOOM_LVL_OUT_2X:

   334

			for (te = _text_effect_list; te != endof(_text_effect_list); te++) {

   335

				if (te->string_id != INVALID_STRING_ID &&

   336

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

   337

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

   338

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

   339

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

   340

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

   341

				}

   342

			}

   343

			break;

   344

   345

		case ZOOM_LVL_OUT_4X:

   346

		case ZOOM_LVL_OUT_8X:

   347

			break;

   348

   349

		default: NOT_REACHED();

   350

	}

   351

}

   352

   353

void DeleteAnimatedTile(TileIndex tile)

   354

{

   355

	TileIndex *ti;

   356

   357

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

   358

		if (tile == *ti) {

   359

			/* remove the hole */

   360

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

   361

			/* and clear last item */

   362

			*lastof(_animated_tile_list) = 0;

   363

			MarkTileDirtyByTile(tile);

   364

			return;

   365

		}

   366

	}

   367

}

   368

   369

bool AddAnimatedTile(TileIndex tile)

   370

{

   371

	TileIndex *ti;

   372

   373

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

   374

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

   375

			*ti = tile;

   376

			MarkTileDirtyByTile(tile);

   377

			return true;

   378

		}

   379

	}

   380

   381

	return false;

   382

}

   383

   384

void AnimateAnimatedTiles()

   385

{

   386

	const TileIndex* ti;

   387

   388

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

   389

		AnimateTile(*ti);

   390

	}

   391

}

   392

   393

void InitializeAnimatedTiles()

   394

{

   395

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

   396

}

   397

   398

static void SaveLoad_ANIT()

   399

{

   400

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

   401

	if (CheckSavegameVersion(6)) {

   402

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

   403

	} else {

   404

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

   405

	}

   406

}

   407

   408

   409

extern const ChunkHandler _animated_tile_chunk_handlers[] = {

   410

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

   411

};