1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "strings.h"

     7

#include "gfx.h"

     8

#include "viewport.h"

     9

#include "saveload.h"

    10

#include "hal.h"

    11

#include "console.h"

    12

#include "string.h"

    13

#include "variables.h"

    14

#include "table/sprites.h"

    15

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

    16

    17

typedef struct TextEffect {

    18

	StringID string_id;

    19

	int32 x;

    20

	int32 y;

    21

	int32 right;

    22

	int32 bottom;

    23

	uint16 duration;

    24

	uint32 params_1;

    25

	uint32 params_2;

    26

} TextEffect;

    27

    28

#define MAX_TEXTMESSAGE_LENGTH 250

    29

    30

typedef struct TextMessage {

    31

	char message[MAX_TEXTMESSAGE_LENGTH];

    32

	uint16 color;

    33

	uint16 end_date;

    34

} TextMessage;

    35

    36

#define MAX_CHAT_MESSAGES 10

    37

static TextEffect _text_effect_list[30];

    38

static TextMessage _text_message_list[MAX_CHAT_MESSAGES];

    39

TileIndex _animated_tile_list[256];

    40

    41

    45

    50

    51

static Pixel _textmessage_backup[150 * 400]; // (y * max_width)

    52

    53

extern void memcpy_pitch(void *d, void *s, int w, int h, int spitch, int dpitch);

    54

    55

// Duration is in game-days

    56

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

    57

{

    58

	char buf[MAX_TEXTMESSAGE_LENGTH];

    59

	va_list va;

    60

	size_t length;

    61

	uint i;

    62

    63

	va_start(va, message);

    64

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

    65

	va_end(va);

    66

    67

	/* Special color magic */

    68

	if ((color & 0xFF) == 0xC9) color = 0x1CA;

    69

    70

	/* Cut the message till it fits inside the chatbox */

    71

	length = strlen(buf);

    72

	while (GetStringWidth(buf) > _textmessage_width - 9) buf[--length] = '\0';

    73

    74

	/* Find an empty spot and put the message there */

    75

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

    76

		if (_text_message_list[i].message[0] == '\0') {

    77

			// Empty spot

    78

			ttd_strlcpy(_text_message_list[i].message, buf, sizeof(_text_message_list[i].message));

    79

			_text_message_list[i].color = color;

    80

			_text_message_list[i].end_date = _date + duration;

    81

    82

			_textmessage_dirty = true;

    83

			return;

    84

		}

    85

	}

    86

    87

	// We did not found a free spot, trash the first one, and add to the end

    88

	memmove(&_text_message_list[0], &_text_message_list[1], sizeof(_text_message_list[0]) * (MAX_CHAT_MESSAGES - 1));

    89

	ttd_strlcpy(_text_message_list[MAX_CHAT_MESSAGES - 1].message, buf, sizeof(_text_message_list[MAX_CHAT_MESSAGES - 1].message));

    90

	_text_message_list[MAX_CHAT_MESSAGES - 1].color = color;

    91

	_text_message_list[MAX_CHAT_MESSAGES - 1].end_date = _date + duration;

    92

    93

	_textmessage_dirty = true;

    94

}

    95

    96

void InitTextMessage(void)

    97

{

    98

	int i;

    99

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

   100

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

   101

   102

	_textmessage_width = _textmessage_box_max_width;

   103

}

   104

   105

// Hide the textbox

   106

void UndrawTextMessage(void)

   107

{

   108

	if (_textmessage_visible) {

   109

		// Sometimes we also need to hide the cursor

   110

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

   111

		//   screen before drawing.

   112

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

   113

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

   114

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

   115

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

   116

		//   looks nicely ;)

   117

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

   118

   119

		if (_cursor.visible) {

   120

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

   121

				_cursor.draw_pos.x <= _textmessage_box_left + _textmessage_width &&

   122

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

   123

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

   124

				UndrawMouseCursor();

   125

			}

   126

		}

   127

   128

		_textmessage_visible = false;

   129

		// Put our 'shot' back to the screen

   130

		memcpy_pitch(

   131

			_screen.dst_ptr + _textmessage_box_left + (_screen.height-_textmessage_box_bottom-_textmessage_box_y) * _screen.pitch,

   132

			_textmessage_backup,

   133

			_textmessage_width, _textmessage_box_y, _textmessage_width, _screen.pitch);

   134

   135

		// And make sure it is updated next time

   136

		_video_driver->make_dirty(_textmessage_box_left, _screen.height-_textmessage_box_bottom-_textmessage_box_y, _textmessage_width, _textmessage_box_y);

   137

   138

		_textmessage_dirty = true;

   139

	}

   140

}

   141

   142

// Check if a message is expired every day

   143

void TextMessageDailyLoop(void)

   144

{

   145

	int i;

   146

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

   147

		if (_text_message_list[i].message[0] == '\0')

   148

			continue;

   149

   150

		if (_date > _text_message_list[i].end_date) {

   151

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

   152

			if (i != MAX_CHAT_MESSAGES - 1)

   153

				memmove(&_text_message_list[i], &_text_message_list[i + 1], sizeof(_text_message_list[i]) * (MAX_CHAT_MESSAGES - i - 1));

   154

   155

			/* Mark the last item as empty */

   156

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

   157

			_textmessage_dirty = true;

   158

   159

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

   160

			i--;

   161

		}

   162

	}

   163

}

   164

   165

// Draw the textmessage-box

   166

void DrawTextMessage(void)

   167

{

   168

	int i, j;

   169

	bool has_message;

   170

   171

	if (!_textmessage_dirty)

   172

		return;

   173

   174

	// First undraw if needed

   175

	UndrawTextMessage();

   176

   177

	if (_iconsole_mode == ICONSOLE_FULL)

   178

		return;

   179

   180

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

   181

	has_message = false;

   182

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

   183

		if (_text_message_list[i].message[0] == '\0')

   184

			break;

   185

   186

		has_message = true;

   187

	}

   188

	if (!has_message)

   189

		return;

   190

   191

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

   192

	memcpy_pitch(

   193

		_textmessage_backup,

   194

		_screen.dst_ptr + _textmessage_box_left + (_screen.height-_textmessage_box_bottom-_textmessage_box_y) * _screen.pitch,

   195

		_textmessage_width, _textmessage_box_y, _screen.pitch, _textmessage_width);

   196

   197

	// Switch to _screen painting

   198

	_cur_dpi = &_screen;

   199

   200

	j = 0;

   201

	// Paint the messages

   202

	for (i = MAX_CHAT_MESSAGES - 1; i >= 0; i--) {

   203

		if (_text_message_list[i].message[0] == '\0')

   204

			continue;

   205

   206

		j++;

   207

		GfxFillRect(_textmessage_box_left, _screen.height-_textmessage_box_bottom-j*13-2, _textmessage_box_left+_textmessage_width - 1, _screen.height-_textmessage_box_bottom-j*13+10, /* black, but with some alpha */ 0x322 | USE_COLORTABLE);

   208

   209

		DoDrawString(_text_message_list[i].message, _textmessage_box_left + 2, _screen.height - _textmessage_box_bottom - j * 13 - 1, 0x10);

   210

		DoDrawString(_text_message_list[i].message, _textmessage_box_left + 3, _screen.height - _textmessage_box_bottom - j * 13, _text_message_list[i].color);

   211

	}

   212

   213

	// Make sure the data is updated next flush

   214

	_video_driver->make_dirty(_textmessage_box_left, _screen.height-_textmessage_box_bottom-_textmessage_box_y, _textmessage_width, _textmessage_box_y);

   215

   216

	_textmessage_visible = true;

   217

	_textmessage_dirty = false;

   218

}

   219

   220

static void MarkTextEffectAreaDirty(TextEffect *te)

   221

{

   222

	MarkAllViewportsDirty(

   223

		te->x,

   224

		te->y - 1,

   225

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

   226

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

   227

	);

   228

}

   229

   230

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

   231

{

   232

	TextEffect *te;

   233

	int w;

   234

	char buffer[100];

   235

   236

	if (_game_mode == GM_MENU)

   237

		return;

   238

   239

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

   240

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

   241

			return;

   242

	}

   243

   244

	te->string_id = msg;

   245

	te->duration = duration;

   246

	te->y = y - 5;

   247

	te->bottom = y + 5;

   248

	te->params_1 = GetDParam(0);

   249

	te->params_2 = GetDParam(4);

   250

   251

	GetString(buffer, msg);

   252

	w = GetStringWidth(buffer);

   253

   254

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

   255

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

   256

	MarkTextEffectAreaDirty(te);

   257

}

   258

   259

static void MoveTextEffect(TextEffect *te)

   260

{

   261

	if (te->duration < 8) {

   262

		te->string_id = INVALID_STRING_ID;

   263

	} else {

   264

		te->duration-=8;

   265

		te->y--;

   266

		te->bottom--;

   267

	}

   268

	MarkTextEffectAreaDirty(te);

   269

}

   270

   271

void MoveAllTextEffects(void)

   272

{

   273

	TextEffect *te;

   274

   275

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

   276

		if (te->string_id != INVALID_STRING_ID)

   277

			MoveTextEffect(te);

   278

	}

   279

}

   280

   281

void InitTextEffects(void)

   282

{

   283

	TextEffect *te;

   284

   285

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

   286

		te->string_id = INVALID_STRING_ID;

   287

	}

   288

}

   289

   290

void DrawTextEffects(DrawPixelInfo *dpi)

   291

{

   292

	TextEffect *te;

   293

   294

	if (dpi->zoom < 1) {

   295

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

   296

			if (te->string_id == INVALID_STRING_ID)

   297

				continue;

   298

   299

			/* intersection? */

   300

			if (dpi->left > te->right ||

   301

					dpi->top > te->bottom ||

   302

					dpi->left + dpi->width <= te->x ||

   303

					dpi->top + dpi->height <= te->y)

   304

						continue;

   305

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

   306

		}

   307

	} else if (dpi->zoom == 1) {

   308

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

   309

			if (te->string_id == INVALID_STRING_ID)

   310

				continue;

   311

   312

			/* intersection? */

   313

			if (dpi->left > te->right*2 -  te->x ||

   314

					dpi->top > te->bottom*2 - te->y ||

   315

					(dpi->left + dpi->width) <= te->x ||

   316

					(dpi->top + dpi->height) <= te->y)

   317

						continue;

   318

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

   319

		}

   320

   321

	}

   322

}

   323

   324

void DeleteAnimatedTile(TileIndex tile)

   325

{

   326

	TileIndex *ti;

   327

   328

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

   329

		if (tile == *ti) {

   330

			/* remove the hole */

   331

			memmove(ti, ti+1, endof(_animated_tile_list) - 1 - ti);

   332

			/* and clear last item */

   333

			endof(_animated_tile_list)[-1] = 0;

   334

			MarkTileDirtyByTile(tile);

   335

			return;

   336

		}

   337

	}

   338

}

   339

   340

bool AddAnimatedTile(TileIndex tile)

   341

{

   342

	TileIndex *ti;

   343

   344

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

   345

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

   346

			*ti = tile;

   347

			MarkTileDirtyByTile(tile);

   348

			return true;

   349

		}

   350

	}

   351

   352

	return false;

   353

}

   354

   355

void AnimateAnimatedTiles(void)

   356

{

   357

	TileIndex *ti;

   358

	TileIndex tile;

   359

   360

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

   361

		AnimateTile(tile);

   362

	}

   363

}

   364

   365

void InitializeAnimatedTiles(void)

   366

{

   367

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

   368

}

   369

   370

static void SaveLoad_ANIT(void)

   371

{

   372

	if (_sl_version < 6) {

   373

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

   374

	} else

   375

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

   376

}

   377

   378

   379

const ChunkHandler _animated_tile_chunk_handlers[] = {

   380

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

   381

};