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

#include "date.h"

    17

    18

typedef struct TextEffect {

    19

	StringID string_id;

    20

	int32 x;

    21

	int32 y;

    22

	int32 right;

    23

	int32 bottom;

    24

	uint16 duration;

    25

	uint32 params_1;

    26

	uint32 params_2;

    27

} TextEffect;

    28

    29

#define MAX_TEXTMESSAGE_LENGTH 250

    30

    31

typedef struct TextMessage {

    32

	char message[MAX_TEXTMESSAGE_LENGTH];

    33

	uint16 color;

    34

	Date end_date;

    35

} TextMessage;

    36

    37

#define MAX_CHAT_MESSAGES 10

    38

static TextEffect _text_effect_list[30];

    39

static TextMessage _text_message_list[MAX_CHAT_MESSAGES];

    40

TileIndex _animated_tile_list[256];

    41

    42

    43

static int _textmessage_width = 0;

    44

static bool _textmessage_dirty = true;

    45

static bool _textmessage_visible = false;

    46

    47

static const int _textmessage_box_left = 10; // Pixels from left

    48

static const int _textmessage_box_y = 150;  // Height of box

    49

static const int _textmessage_box_bottom = 30; // Pixels from bottom

    50

static const int _textmessage_box_max_width = 400; // Max width of box

    51

    52

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

    53

    54

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

    55

    56

// Duration is in game-days

    57

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

    58

{

    59

	char buf[MAX_TEXTMESSAGE_LENGTH];

    60

	va_list va;

    61

	size_t length;

    62

	uint i;

    63

    64

	va_start(va, message);

    65

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

    66

	va_end(va);

    67

    68

	/* Special color magic */

    69

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

    70

    71

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

    72

	length = strlen(buf);

    73

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

    74

    75

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

    76

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

    77

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

    78

			// Empty spot

    79

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

    80

			_text_message_list[i].color = color;

    81

			_text_message_list[i].end_date = _date + duration;

    82

    83

			_textmessage_dirty = true;

    84

			return;

    85

		}

    86

	}

    87

    88

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

    89

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

    90

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

    91

	_text_message_list[MAX_CHAT_MESSAGES - 1].color = color;

    92

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

    93

    94

	_textmessage_dirty = true;

    95

}

    96

    97

void InitTextMessage(void)

    98

{

    99

	uint i;

   100

   101

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

   102

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

   103

	}

   104

   105

	_textmessage_width = _textmessage_box_max_width;

   106

}

   107

   108

// Hide the textbox

   109

void UndrawTextMessage(void)

   110

{

   111

	if (_textmessage_visible) {

   112

		// Sometimes we also need to hide the cursor

   113

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

   114

		//   screen before drawing.

   115

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

   116

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

   117

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

   118

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

   119

		//   looks nicely ;)

   120

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

   121

   122

		if (_cursor.visible) {

   123

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

   124

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

   125

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

   126

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

   127

				UndrawMouseCursor();

   128

			}

   129

		}

   130

   131

		_textmessage_visible = false;

   132

		// Put our 'shot' back to the screen

   133

		memcpy_pitch(

   134

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

   135

			_textmessage_backup,

   136

			_textmessage_width, _textmessage_box_y, _textmessage_width, _screen.pitch);

   137

   138

		// And make sure it is updated next time

   139

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

   140

   141

		_textmessage_dirty = true;

   142

	}

   143

}

   144

   145

// Check if a message is expired every day

   146

void TextMessageDailyLoop(void)

   147

{

   148

	uint i;

   149

   150

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

   151

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

   152

   153

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

   154

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

   155

			if (i != MAX_CHAT_MESSAGES - 1)

   156

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

   157

   158

			/* Mark the last item as empty */

   159

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

   160

			_textmessage_dirty = true;

   161

   162

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

   163

			i--;

   164

		}

   165

	}

   166

}

   167

   168

// Draw the textmessage-box

   169

void DrawTextMessage(void)

   170

{

   171

	int i, j;

   172

	bool has_message;

   173

   174

	if (!_textmessage_dirty) return;

   175

   176

	// First undraw if needed

   177

	UndrawTextMessage();

   178

   179

	if (_iconsole_mode == ICONSOLE_FULL)

   180

		return;

   181

   182

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

   183

	has_message = false;

   184

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

   185

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

   186

   187

		has_message = true;

   188

	}

   189

	if (!has_message) 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') continue;

   204

   205

		j++;

   206

		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);

   207

   208

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

   209

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

   210

	}

   211

   212

	// Make sure the data is updated next flush

   213

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

   214

   215

	_textmessage_visible = true;

   216

	_textmessage_dirty = false;

   217

}

   218

   219

static void MarkTextEffectAreaDirty(TextEffect *te)

   220

{

   221

	MarkAllViewportsDirty(

   222

		te->x,

   223

		te->y - 1,

   224

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

   225

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

   226

	);

   227

}

   228

   229

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

   230

{

   231

	TextEffect *te;

   232

	int w;

   233

	char buffer[100];

   234

   235

	if (_game_mode == GM_MENU)

   236

		return;

   237

   238

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

   239

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

   240

	}

   241

   242

	te->string_id = msg;

   243

	te->duration = duration;

   244

	te->y = y - 5;

   245

	te->bottom = y + 5;

   246

	te->params_1 = GetDParam(0);

   247

	te->params_2 = GetDParam(4);

   248

   250

	w = GetStringBoundingBox(buffer).width;

   251

   252

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

   253

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

   254

	MarkTextEffectAreaDirty(te);

   255

}

   256

   257

static void MoveTextEffect(TextEffect *te)

   258

{

   259

	if (te->duration < 8) {

   260

		te->string_id = INVALID_STRING_ID;

   261

	} else {

   262

		te->duration -= 8;

   263

		te->y--;

   264

		te->bottom--;

   265

	}

   266

	MarkTextEffectAreaDirty(te);

   267

}

   268

   269

void MoveAllTextEffects(void)

   270

{

   271

	TextEffect *te;

   272

   273

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

   274

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

   275

	}

   276

}

   277

   278

void InitTextEffects(void)

   279

{

   280

	TextEffect *te;

   281

   282

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

   283

		te->string_id = INVALID_STRING_ID;

   284

	}

   285

}

   286

   287

void DrawTextEffects(DrawPixelInfo *dpi)

   288

{

   289

	const TextEffect* te;

   290

   291

	switch (dpi->zoom) {

   292

		case 0:

   293

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

   294

				if (te->string_id != INVALID_STRING_ID &&

   295

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

   296

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

   297

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

   298

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

   299

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

   300

				}

   301

			}

   302

			break;

   303

   304

		case 1:

   305

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

   306

				if (te->string_id != INVALID_STRING_ID &&

   307

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

   308

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

   309

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

   310

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

   311

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

   312

				}

   313

			}

   314

			break;

   315

	}

   316

}

   317

   318

void DeleteAnimatedTile(TileIndex tile)

   319

{

   320

	TileIndex* ti;

   321

   322

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

   323

		if (tile == *ti) {

   324

			/* remove the hole */

   325

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

   326

			/* and clear last item */

   327

			endof(_animated_tile_list)[-1] = 0;

   328

			MarkTileDirtyByTile(tile);

   329

			return;

   330

		}

   331

	}

   332

}

   333

   334

bool AddAnimatedTile(TileIndex tile)

   335

{

   336

	TileIndex* ti;

   337

   338

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

   339

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

   340

			*ti = tile;

   341

			MarkTileDirtyByTile(tile);

   342

			return true;

   343

		}

   344

	}

   345

   346

	return false;

   347

}

   348

   349

void AnimateAnimatedTiles(void)

   350

{

   351

	const TileIndex* ti;

   352

   353

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

   354

		AnimateTile(*ti);

   355

	}

   356

}

   357

   358

void InitializeAnimatedTiles(void)

   359

{

   360

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

   361

}

   362

   363

static void SaveLoad_ANIT(void)

   364

{

   365

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

   366

	if (CheckSavegameVersion(6)) {

   367

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

   368

	} else {

   369

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

   370

	}

   371

}

   372

   373

   374

const ChunkHandler _animated_tile_chunk_handlers[] = {

   375

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

   376

};