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

    26

typedef struct TextEffect {

    27

	StringID string_id;

    28

	int32 x;

    29

	int32 y;

    30

	int32 right;

    31

	int32 bottom;

    32

	uint16 duration;

    33

	uint32 params_1;

    34

	uint32 params_2;

    35

} TextEffect;

    36

    37

    38

typedef struct TextMessage {

    39

	char message[MAX_TEXTMESSAGE_LENGTH];

    40

	uint16 color;

    41

	Date end_date;

    42

} TextMessage;

    43

    45

static TextMessage _textmsg_list[MAX_CHAT_MESSAGES];

    47

    48

static bool _textmessage_dirty = false;

    49

static bool _textmessage_visible = false;

    50

    51

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

    52

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

    53

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

    54

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

    55

    56

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

    57

    58

static inline uint GetTextMessageCount(void)

    59

{

    60

	uint i;

    61

    62

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

    63

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

    64

	}

    65

    66

	return i;

    67

}

    68

    69

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

    70

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

    71

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

    72

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

    73

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

    74

{

    75

	char buf[MAX_TEXTMESSAGE_LENGTH];

    76

	const char *bufp;

    77

	va_list va;

    78

	uint msg_count;

    79

	uint16 lines;

    80

    81

	va_start(va, message);

    82

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

    83

	va_end(va);

    84

    85

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

    86

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

    87

	if (lines >= MAX_CHAT_MESSAGES) return;

    88

    89

	msg_count = GetTextMessageCount();

    90

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

    91

	if (lines > MAX_CHAT_MESSAGES - msg_count) {

    92

		int i = lines - (MAX_CHAT_MESSAGES - msg_count);

    93

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

    94

		msg_count = MAX_CHAT_MESSAGES - lines;

    95

	}

    96

    97

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

    98

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

    99

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

   100

   101

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

   102

		 * white for any additional lines */

   103

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

   104

		tmsg->end_date = _date + duration;

   105

   106

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

   107

	}

   108

   109

	_textmessage_dirty = true;

   110

}

   111

   112

void InitTextMessage(void)

   113

{

   114

	uint i;

   115

   116

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

   117

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

   118

	}

   119

}

   120

   122

void UndrawTextMessage(void)

   123

{

   124

	if (_textmessage_visible) {

   135

   136

		if (_cursor.visible) {

   137

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

   138

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

   139

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

   140

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

   141

				UndrawMouseCursor();

   142

			}

   143

		}

   144

   145

		_textmessage_visible = false;

   147

		memcpy_pitch(

   148

			_screen.dst_ptr + _textmsg_box.x + (_screen.height - _textmsg_box.y - _textmsg_box.height) * _screen.pitch,

   149

			_textmessage_backup,

   150

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

   151

   153

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

   154

   155

		_textmessage_dirty = true;

   156

	}

   157

}

   158

   160

void TextMessageDailyLoop(void)

   161

{

   162

	uint i;

   163

   164

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

   165

		TextMessage *tmsg = &_textmsg_list[i];

   166

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

   167

   168

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

   169

		if (tmsg->end_date < _date) {

   170

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

   171

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

   172

   173

			/* Mark the last item as empty */

   174

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

   175

			_textmessage_dirty = true;

   176

   177

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

   178

			i--;

   179

		}

   180

	}

   181

}

   182

   184

void DrawTextMessage(void)

   185

{

   186

	uint y, count;

   187

   188

	if (!_textmessage_dirty) return;

   189

   191

	UndrawTextMessage();

   192

   193

	if (_iconsole_mode == ICONSOLE_FULL) return;

   194

   195

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

   196

	count = GetTextMessageCount();

   197

	if (count == 0) return;

   198

   200

	memcpy_pitch(

   201

		_textmessage_backup,

   202

		_screen.dst_ptr + _textmsg_box.x + (_screen.height - _textmsg_box.y - _textmsg_box.height) * _screen.pitch,

   203

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

   204

   205

	_cur_dpi = &_screen; // switch to _screen painting

   206

   207

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

   208

	GfxFillRect(

   209

			_textmsg_box.x,

   210

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

   211

			_textmsg_box.x + _textmsg_box.width - 1,

   212

			_screen.height - _textmsg_box.y - 2,

   213

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

   214

		);

   215

   216

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

   217

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

   218

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

   219

 	}

   220

   222

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

   223

   224

	_textmessage_visible = true;

   225

	_textmessage_dirty = false;

   226

}

   227

   228

static void MarkTextEffectAreaDirty(TextEffect *te)

   229

{

   230

	MarkAllViewportsDirty(

   231

		te->x,

   232

		te->y - 1,

   233

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

   234

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

   235

	);

   236

}

   237

   238

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

   239

{

   240

	TextEffect *te;

   241

	int w;

   242

	char buffer[100];

   243

   244

	if (_game_mode == GM_MENU) return;

   245

   246

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

   247

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

   248

	}

   249

   250

	te->string_id = msg;

   251

	te->duration = duration;

   252

	te->y = y - 5;

   253

	te->bottom = y + 5;

   254

	te->params_1 = GetDParam(0);

   255

	te->params_2 = GetDParam(4);

   256

   257

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

   258

	w = GetStringBoundingBox(buffer).width;

   259

   260

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

   261

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

   262

	MarkTextEffectAreaDirty(te);

   263

}

   264

   265

static void MoveTextEffect(TextEffect *te)

   266

{

   267

	if (te->duration < 8) {

   268

		te->string_id = INVALID_STRING_ID;

   269

	} else {

   270

		te->duration -= 8;

   271

		te->y--;

   272

		te->bottom--;

   273

	}

   274

	MarkTextEffectAreaDirty(te);

   275

}

   276

   277

void MoveAllTextEffects(void)

   278

{

   279

	TextEffect *te;

   280

   281

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

   282

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

   283

	}

   284

}

   285

   286

void InitTextEffects(void)

   287

{

   288

	TextEffect *te;

   289

   290

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

   291

		te->string_id = INVALID_STRING_ID;

   292

	}

   293

}

   294

   295

void DrawTextEffects(DrawPixelInfo *dpi)

   296

{

   297

	const TextEffect* te;

   298

   299

	switch (dpi->zoom) {

   300

		case 0:

   301

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

   302

				if (te->string_id != INVALID_STRING_ID &&

   303

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

   304

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

   305

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

   306

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

   307

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

   308

				}

   309

			}

   310

			break;

   311

   312

		case 1:

   313

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

   314

				if (te->string_id != INVALID_STRING_ID &&

   315

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

   316

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

   317

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

   318

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

   319

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

   320

				}

   321

			}

   322

			break;

   323

	}

   324

}

   325

   326

void DeleteAnimatedTile(TileIndex tile)

   327

{

   329

   330

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

   331

		if (tile == *ti) {

   332

			/* remove the hole */

   334

			/* and clear last item */

   336

			MarkTileDirtyByTile(tile);

   337

			return;

   338

		}

   339

	}

   340

}

   341

   342

bool AddAnimatedTile(TileIndex tile)

   343

{

   345

   346

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

   347

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

   348

			*ti = tile;

   349

			MarkTileDirtyByTile(tile);

   350

			return true;

   351

		}

   352

	}

   353

   354

	return false;

   355

}

   356

   357

void AnimateAnimatedTiles(void)

   358

{

   359

	const TileIndex* ti;

   360

   361

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

   362

		AnimateTile(*ti);

   363

	}

   364

}

   365

   366

void InitializeAnimatedTiles(void)

   367

{

   368

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

   369

}

   370

   371

static void SaveLoad_ANIT(void)

   372

{

   374

	if (CheckSavegameVersion(6)) {

   375

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

   376

	} else {

   377

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

   378

	}

   379

}

   380

   381

   382

const ChunkHandler _animated_tile_chunk_handlers[] = {

   383

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

   384

};