1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "gfx.h"

     4

#include "viewport.h"

     5

#include "saveload.h"

     6

#include "hal.h"

     7

#include "console.h"

     8

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

     9

    10

typedef struct TextEffect {

    11

	StringID string_id;

    12

	int32 x;

    13

	int32 y;

    14

	int32 right;

    15

	int32 bottom;

    16

	uint16 duration;

    17

	uint32 params_1;

    18

	uint32 params_2;

    19

} TextEffect;

    20

    21

#define MAX_TEXTMESSAGE_LENGTH 250

    22

    23

typedef struct TextMessage {

    24

	char message[MAX_TEXTMESSAGE_LENGTH];

    25

	uint16 color;

    26

	uint16 end_date;

    27

} TextMessage;

    28

    29

#define MAX_CHAT_MESSAGES 10

    30

static TextEffect _text_effect_list[30];

    31

static TextMessage _text_message_list[MAX_CHAT_MESSAGES];

    32

TileIndex _animated_tile_list[256];

    33

    34

    35

int _textmessage_width = 0;

    36

bool _textmessage_dirty = true;

    37

bool _textmessage_visible = false;

    38

    39

const int _textmessage_box_left = 10; // Pixels from left

    40

const int _textmessage_box_y = 150;  // Height of box

    41

const int _textmessage_box_bottom = 30; // Pixels from bottom

    42

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

    43

    44

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

    45

    46

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

    47

    48

// Duration is in game-days

    49

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

    50

{

    51

	int i;

    52

	char buf[1024];

    53

	char buf2[MAX_TEXTMESSAGE_LENGTH];

    54

	va_list va;

    55

	int length;

    56

    57

	va_start(va, message);

    58

	vsprintf(buf, message, va);

    59

	va_end(va);

    60

    61

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

    62

    63

	length = MAX_TEXTMESSAGE_LENGTH;

    64

	snprintf(buf2, length, "%s", buf);

    65

	while (GetStringWidth(buf2) > _textmessage_width - 9) {

    66

		snprintf(buf2, --length, "%s", buf);

    67

	}

    68

    69

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

    70

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

    71

			// Empty spot

    72

			snprintf(_text_message_list[i].message, MAX_TEXTMESSAGE_LENGTH, "%s", buf2);

    73

			_text_message_list[i].color = color;

    74

			_text_message_list[i].end_date = _date + duration;

    75

    76

			_textmessage_dirty = true;

    77

			return;

    78

		}

    79

	}

    80

    81

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

    82

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

    83

	snprintf(_text_message_list[MAX_CHAT_MESSAGES - 1].message, MAX_TEXTMESSAGE_LENGTH, "%s", buf2);

    84

	_text_message_list[MAX_CHAT_MESSAGES - 1].color = color;

    85

	_text_message_list[i].end_date = _date + duration;

    86

    87

	_textmessage_dirty = true;

    88

}

    89

    90

void InitTextMessage(void)

    91

{

    92

	int i;

    93

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

    94

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

    95

	}

    96

    97

	_textmessage_width = _textmessage_box_max_width;

    98

}

    99

   100

// Hide the textbox

   101

void UndrawTextMessage(void)

   102

{

   103

	if (_textmessage_visible) {

   104

		// Sometimes we also need to hide the cursor

   105

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

   106

		//   screen before drawing.

   107

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

   108

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

   109

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

   110

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

   111

		//   looks nicely ;)

   112

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

   113

   114

		if (_cursor.visible) {

   115

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

   116

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

   117

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

   118

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

   119

				UndrawMouseCursor();

   120

			}

   121

		}

   122

   123

		_textmessage_visible = false;

   124

		// Put our 'shot' back to the screen

   125

		memcpy_pitch(

   126

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

   127

			_textmessage_backup,

   128

			_textmessage_width, _textmessage_box_y, _textmessage_width, _screen.pitch);

   129

   130

		// And make sure it is updated next time

   131

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

   132

   133

		_textmessage_dirty = true;

   134

	}

   135

}

   136

   137

// Check if a message is expired every day

   138

void TextMessageDailyLoop(void)

   139

{

   140

	int i = 0;

   141

	while (i < MAX_CHAT_MESSAGES) {

   142

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

   143

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

   144

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

   145

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

   146

			i--;

   147

			_textmessage_dirty = true;

   148

		}

   149

		i++;

   150

	}

   151

}

   152

   153

// Draw the textmessage-box

   154

void DrawTextMessage(void)

   155

{

   156

	int i, j;

   157

	bool has_message;

   158

   159

	if (!_textmessage_dirty)

   160

		return;

   161

   162

	// First undraw if needed

   163

	UndrawTextMessage();

   164

   165

	if (_iconsole_mode == ICONSOLE_FULL)

   166

		return;

   167

   168

	has_message = false;

   169

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

   170

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

   171

		has_message = true;

   172

	}

   173

	if (!has_message) return;

   174

   175

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

   176

	memcpy_pitch(

   177

		_textmessage_backup,

   178

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

   179

		_textmessage_width, _textmessage_box_y, _screen.pitch, _textmessage_width);

   180

   181

	// Switch to _screen painting

   182

	_cur_dpi = &_screen;

   183

   184

	j = 0;

   185

	// Paint the messages

   186

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

   187

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

   188

		j++;

   189

		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 */ 0x4322);

   190

   191

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

   192

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

   193

	}

   194

   195

	// Make sure the data is updated next flush

   196

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

   197

   198

	_textmessage_visible = true;

   199

	_textmessage_dirty = false;

   200

}

   201

   202

static void MarkTextEffectAreaDirty(TextEffect *te)

   203

{

   204

	MarkAllViewportsDirty(

   205

		te->x,

   206

		te->y - 1,

   207

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

   208

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

   209

	);

   210

}

   211

   212

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

   213

{

   214

	TextEffect *te;

   215

	int w;

   216

	char buffer[100];

   217

   218

	if (_game_mode == GM_MENU)

   219

		return;

   220

   221

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

   222

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

   223

			return;

   224

	}

   225

   226

	te->string_id = msg;

   227

	te->duration = duration;

   228

	te->y = y - 5;

   229

	te->bottom = y + 5;

   230

	te->params_1 = GetDParam(0);

   231

	te->params_2 = GetDParam(4);

   232

   233

	GetString(buffer, msg);

   234

	w = GetStringWidth(buffer);

   235

   236

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

   237

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

   238

	MarkTextEffectAreaDirty(te);

   239

}

   240

   241

static void MoveTextEffect(TextEffect *te)

   242

{

   243

	if (te->duration < 8) {

   244

		te->string_id = 0xFFFF;

   245

	} else {

   246

		te->duration-=8;

   247

		te->y--;

   248

		te->bottom--;

   249

	}

   250

	MarkTextEffectAreaDirty(te);

   251

}

   252

   253

void MoveAllTextEffects(void)

   254

{

   255

	TextEffect *te;

   256

   257

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

   258

		if (te->string_id != 0xFFFF)

   259

			MoveTextEffect(te);

   260

	}

   261

}

   262

   263

void InitTextEffects(void)

   264

{

   265

	TextEffect *te;

   266

   267

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

   268

		te->string_id = 0xFFFF;

   269

	}

   270

}

   271

   272

void DrawTextEffects(DrawPixelInfo *dpi)

   273

{

   274

	TextEffect *te;

   275

   276

	if (dpi->zoom < 1) {

   277

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

   278

			if (te->string_id == 0xFFFF)

   279

				continue;

   280

   281

			/* intersection? */

   282

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

   283

					dpi->top > te->bottom ||

   284

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

   285

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

   286

						continue;

   287

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

   288

		}

   289

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

   290

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

   291

			if (te->string_id == 0xFFFF)

   292

				continue;

   293

   294

			/* intersection? */

   295

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

   296

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

   297

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

   298

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

   299

						continue;

   300

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

   301

		}

   302

   303

	}

   304

}

   305

   306

void DeleteAnimatedTile(uint tile)

   307

{

   308

	TileIndex *ti;

   309

   310

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

   311

		if ( (TileIndex)tile == *ti) {

   312

			/* remove the hole */

   313

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

   314

			/* and clear last item */

   315

			endof(_animated_tile_list)[-1] = 0;

   316

			MarkTileDirtyByTile(tile);

   317

			return;

   318

		}

   319

	}

   320

}

   321

   322

bool AddAnimatedTile(uint tile)

   323

{

   324

	TileIndex *ti;

   325

   326

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

   327

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

   328

			*ti = tile;

   329

			MarkTileDirtyByTile(tile);

   330

			return true;

   331

		}

   332

	}

   333

   334

	return false;

   335

}

   336

   337

void AnimateAnimatedTiles(void)

   338

{

   339

	TileIndex *ti;

   340

	uint tile;

   341

   342

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

   343

		AnimateTile(tile);

   344

	}

   345

}

   346

   347

void InitializeAnimatedTiles(void)

   348

{

   349

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

   350

}

   351

   352

static void SaveLoad_ANIT(void)

   353

{

   354

	if (_sl.version < 6)

   355

		SlArray(_animated_tile_list, lengthof(_animated_tile_list),

   356

			SLE_FILE_U16 | SLE_VAR_U32);

   357

	else

   358

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

   359

}

   360

   361

   362

const ChunkHandler _animated_tile_chunk_handlers[] = {

   363

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

   364

};

   365

   366