1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "macros.h"

     7

#include "strings.h"

     8

#include "gfx.h"

     9

#include "viewport.h"

    10

#include "saveload.h"

    11

#include "hal.h"

    12

#include "console.h"

    13

#include "string.h"

    14

#include "variables.h"

    15

#include "table/sprites.h"

    16

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

    17

#include "date.h"

    18

    19

typedef struct TextEffect {

    20

	StringID string_id;

    21

	int32 x;

    22

	int32 y;

    23

	int32 right;

    24

	int32 bottom;

    25

	uint16 duration;

    26

	uint32 params_1;

    27

	uint32 params_2;

    28

} TextEffect;

    29

    30

#define MAX_TEXTMESSAGE_LENGTH 200

    31

    32

typedef struct TextMessage {

    33

	char message[MAX_TEXTMESSAGE_LENGTH];

    34

	uint16 color;

    35

	Date end_date;

    36

} TextMessage;

    37

    38

#define MAX_CHAT_MESSAGES 10

    39

static TextEffect _text_effect_list[30];

    40

static TextMessage _textmsg_list[MAX_CHAT_MESSAGES];

    41

TileIndex _animated_tile_list[256];

    42

    43

static bool _textmessage_dirty = false;

    44

static bool _textmessage_visible = false;

    45

    46

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

    47

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

    48

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

    49

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

    50

    51

extern void memcpy_pitch(void *dst, void *src, int w, int h, int srcpitch, int dstpitch);

    52

    53

static inline uint GetTextMessageCount(void)

    54

{

    55

	uint i;

    56

    57

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

    58

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

    59

	}

    60

    61

	return i;

    62

}

    63

    64

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

    65

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

    66

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

    67

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

    68

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

    69

{

    70

	char buf[MAX_TEXTMESSAGE_LENGTH];

    71

	const char *bufp;

    72

	va_list va;

    73

	uint msg_count;

    74

	uint16 lines;

    75

    76

	va_start(va, message);

    77

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

    78

	va_end(va);

    79

    80

    81

	Utf8TrimString(buf, MAX_TEXTMESSAGE_LENGTH);

    82

    83

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

    84

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

    85

	if (lines >= MAX_CHAT_MESSAGES) return;

    86

    87

	msg_count = GetTextMessageCount();

    88

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

    89

	if (lines > MAX_CHAT_MESSAGES - msg_count) {

    90

		int i = lines - (MAX_CHAT_MESSAGES - msg_count);

    91

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

    92

		msg_count = MAX_CHAT_MESSAGES - lines;

    93

	}

    94

    95

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

    96

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

    97

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

    98

    99

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

   100

		 * white for any additional lines */

   101

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

   102

		tmsg->end_date = _date + duration;

   103

   104

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

   105

	}

   106

   107

	_textmessage_dirty = true;

   108

}

   109

   110

void InitTextMessage(void)

   111

{

   112

	uint i;

   113

   114

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

   115

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

   116

	}

   117

}

   118

   119

// Hide the textbox

   120

void UndrawTextMessage(void)

   121

{

   122

	if (_textmessage_visible) {

   123

		int x, y, width, height;

   124

   125

		// Sometimes we also need to hide the cursor

   126

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

   127

		//   screen before drawing.

   128

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

   129

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

   130

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

   131

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

   132

		//   looks nicely ;)

   133

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

   134

   135

		if (_cursor.visible) {

   136

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

   137

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

   138

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

   139

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

   140

				UndrawMouseCursor();

   141

			}

   142

		}

   143

   144

		x      = _textmsg_box.x;

   145

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

   146

		width  = _textmsg_box.width;

   147

		height = _textmsg_box.height;

   148

		if (y < 0) {

   149

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

   150

			y = 0;

   151

		}

   152

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

   153

			width = _screen.width - x;

   154

		}

   155

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

   156

   157

		_textmessage_visible = false;

   158

		// Put our 'shot' back to the screen

   159

		memcpy_pitch(

   160

			_screen.dst_ptr + x + y * _screen.pitch,

   161

			_textmessage_backup,

   162

			width, height, _textmsg_box.width, _screen.pitch);

   163

   164

		// And make sure it is updated next time

   165

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

   166

   167

		_textmessage_dirty = true;

   168

	}

   169

}

   170

   171

// Check if a message is expired every day

   172

void TextMessageDailyLoop(void)

   173

{

   174

	uint i;

   175

   176

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

   177

		TextMessage *tmsg = &_textmsg_list[i];

   178

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

   179

   180

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

   181

		if (tmsg->end_date < _date) {

   182

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

   183

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

   184

   185

			/* Mark the last item as empty */

   186

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

   187

			_textmessage_dirty = true;

   188

   189

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

   190

			i--;

   191

		}

   192

	}

   193

}

   194

   195

// Draw the textmessage-box

   196

void DrawTextMessage(void)

   197

{

   198

	int x, y, width, height;

   199

	uint offset_y, count;

   200

   201

	if (!_textmessage_dirty) return;

   202

   203

	// First undraw if needed

   204

	UndrawTextMessage();

   205

   206

	if (_iconsole_mode == ICONSOLE_FULL) return;

   207

   208

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

   209

	count = GetTextMessageCount();

   210

	if (count == 0) return;

   211

   212

	x      = _textmsg_box.x;

   213

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

   214

	width  = _textmsg_box.width;

   215

	height = _textmsg_box.height;

   216

	if (y < 0) {

   217

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

   218

		y = 0;

   219

	}

   220

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

   221

		width = _screen.width - x;

   222

	}

   223

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

   224

   225

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

   226

	memcpy_pitch(

   227

		_textmessage_backup,

   228

		_screen.dst_ptr + x + y * _screen.pitch,

   229

		width, height, _screen.pitch, _textmsg_box.width);

   230

   231

	_cur_dpi = &_screen; // switch to _screen painting

   232

   233

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

   234

	GfxFillRect(

   235

			_textmsg_box.x,

   236

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

   237

			_textmsg_box.x + _textmsg_box.width - 1,

   238

			_screen.height - _textmsg_box.y - 2,

   239

			0x322 | USE_COLORTABLE // black, but with some alpha for background

   240

		);

   241

   242

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

   243

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

   244

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

   245

 	}

   246

   247

	// Make sure the data is updated next flush

   248

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

   249

   250

	_textmessage_visible = true;

   251

	_textmessage_dirty = false;

   252

}

   253

   254

static void MarkTextEffectAreaDirty(TextEffect *te)

   255

{

   256

	MarkAllViewportsDirty(

   257

		te->x,

   258

		te->y - 1,

   259

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

   260

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

   261

	);

   262

}

   263

   264

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

   265

{

   266

	TextEffect *te;

   267

	int w;

   268

	char buffer[100];

   269

   270

	if (_game_mode == GM_MENU) return;

   271

   272

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

   273

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

   274

	}

   275

   276

	te->string_id = msg;

   277

	te->duration = duration;

   278

	te->y = y - 5;

   279

	te->bottom = y + 5;

   280

	te->params_1 = GetDParam(0);

   281

	te->params_2 = GetDParam(4);

   282

   283

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

   284

	w = GetStringBoundingBox(buffer).width;

   285

   286

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

   287

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

   288

	MarkTextEffectAreaDirty(te);

   289

}

   290

   291

static void MoveTextEffect(TextEffect *te)

   292

{

   293

	if (te->duration < 8) {

   294

		te->string_id = INVALID_STRING_ID;

   295

	} else {

   296

		te->duration -= 8;

   297

		te->y--;

   298

		te->bottom--;

   299

	}

   300

	MarkTextEffectAreaDirty(te);

   301

}

   302

   303

void MoveAllTextEffects(void)

   304

{

   305

	TextEffect *te;

   306

   307

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

   308

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

   309

	}

   310

}

   311

   312

void InitTextEffects(void)

   313

{

   314

	TextEffect *te;

   315

   316

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

   317

		te->string_id = INVALID_STRING_ID;

   318

	}

   319

}

   320

   321

void DrawTextEffects(DrawPixelInfo *dpi)

   322

{

   323

	const TextEffect* te;

   324

   325

	switch (dpi->zoom) {

   326

		case 0:

   327

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

   328

				if (te->string_id != INVALID_STRING_ID &&

   329

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

   330

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

   331

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

   332

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

   333

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

   334

				}

   335

			}

   336

			break;

   337

   338

		case 1:

   339

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

   340

				if (te->string_id != INVALID_STRING_ID &&

   341

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

   342

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

   343

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

   344

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

   345

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

   346

				}

   347

			}

   348

			break;

   349

	}

   350

}

   351

   352

void DeleteAnimatedTile(TileIndex tile)

   353

{

   354

	TileIndex* ti;

   355

   356

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

   357

		if (tile == *ti) {

   358

			/* remove the hole */

   359

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

   360

			/* and clear last item */

   361

			endof(_animated_tile_list)[-1] = 0;

   362

			MarkTileDirtyByTile(tile);

   363

			return;

   364

		}

   365

	}

   366

}

   367

   368

bool AddAnimatedTile(TileIndex tile)

   369

{

   370

	TileIndex* ti;

   371

   372

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

   373

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

   374

			*ti = tile;

   375

			MarkTileDirtyByTile(tile);

   376

			return true;

   377

		}

   378

	}

   379

   380

	return false;

   381

}

   382

   383

void AnimateAnimatedTiles(void)

   384

{

   385

	const TileIndex* ti;

   386

   387

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

   388

		AnimateTile(*ti);

   389

	}

   390

}

   391

   392

void InitializeAnimatedTiles(void)

   393

{

   394

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

   395

}

   396

   397

static void SaveLoad_ANIT(void)

   398

{

   399

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

   400

	if (CheckSavegameVersion(6)) {

   401

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

   402

	} else {

   403

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

   404

	}

   405

}

   406

   407

   408

const ChunkHandler _animated_tile_chunk_handlers[] = {

   409

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

   410

};