1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "strings.h"

     4

#include "gfx.h"

     5

#include "viewport.h"

     6

#include "saveload.h"

     7

#include "hal.h"

     8

#include "console.h"

     9

#include "string.h"

    10

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

    11

    12

typedef struct TextEffect {

    13

	StringID string_id;

    14

	int32 x;

    15

	int32 y;

    16

	int32 right;

    17

	int32 bottom;

    18

	uint16 duration;

    19

	uint32 params_1;

    20

	uint32 params_2;

    21

} TextEffect;

    22

    23

#define MAX_TEXTMESSAGE_LENGTH 250

    24

    25

typedef struct TextMessage {

    26

	char message[MAX_TEXTMESSAGE_LENGTH];

    27

	uint16 color;

    28

	uint16 end_date;

    29

} TextMessage;

    30

    31

#define MAX_CHAT_MESSAGES 10

    32

static TextEffect _text_effect_list[30];

    33

static TextMessage _text_message_list[MAX_CHAT_MESSAGES];

    34

TileIndex _animated_tile_list[256];

    35

    36

    37

int _textmessage_width = 0;

    38

bool _textmessage_dirty = true;

    39

bool _textmessage_visible = false;

    40

    41

const int _textmessage_box_left = 10; // Pixels from left

    42

const int _textmessage_box_y = 150;  // Height of box

    43

const int _textmessage_box_bottom = 30; // Pixels from bottom

    44

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

    45

    47

    48

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

    49

    50

// Duration is in game-days

    51

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

    52

{

    53

	int i;

    54

	char buf[1024];

    55

	char buf2[MAX_TEXTMESSAGE_LENGTH];

    56

	va_list va;

    57

	int length;

    58

    59

	va_start(va, message);

    60

	vsprintf(buf, message, va);

    61

	va_end(va);

    62

    63

	/* Special color magic */

    64

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

    65

		color = 0x1CA;

    66

    67

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

    68

	length = strlen(buf) + 1;

    69

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

    70

	while (GetStringWidth(buf2) > _textmessage_width - 9)

    71

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

    72

    73

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

    74

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

    75

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

    76

			// Empty spot

    77

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

    78

			_text_message_list[i].color = color;

    79

			_text_message_list[i].end_date = _date + duration;

    80

    81

			_textmessage_dirty = true;

    82

			return;

    83

		}

    84

	}

    85

    86

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

    87

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

    88

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

    89

	_text_message_list[MAX_CHAT_MESSAGES - 1].color = color;

    90

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

    91

    92

	_textmessage_dirty = true;

    93

}

    94

    95

void InitTextMessage(void)

    96

{

    97

	int i;

    98

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

    99

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

   100

   101

	_textmessage_width = _textmessage_box_max_width;

   102

}

   103

   104

// Hide the textbox

   105

void UndrawTextMessage(void)

   106

{

   107

	if (_textmessage_visible) {

   108

		// Sometimes we also need to hide the cursor

   109

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

   110

		//   screen before drawing.

   111

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

   112

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

   113

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

   114

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

   115

		//   looks nicely ;)

   116

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

   117

   118

		if (_cursor.visible) {

   119

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

   120

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

   121

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

   122

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

   123

				UndrawMouseCursor();

   124

			}

   125

		}

   126

   127

		_textmessage_visible = false;

   128

		// Put our 'shot' back to the screen

   129

		memcpy_pitch(

   130

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

   131

			_textmessage_backup,

   132

			_textmessage_width, _textmessage_box_y, _textmessage_width, _screen.pitch);

   133

   134

		// And make sure it is updated next time

   135

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

   136

   137

		_textmessage_dirty = true;

   138

	}

   139

}

   140

   141

// Check if a message is expired every day

   142

void TextMessageDailyLoop(void)

   143

{

   144

	int i;

   145

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

   146

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

   147

			continue;

   148

   149

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

   150

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

   151

			if (i != MAX_CHAT_MESSAGES - 1)

   152

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

   153

   154

			/* Mark the last item as empty */

   155

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

   156

			_textmessage_dirty = true;

   157

   158

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

   159

			i--;

   160

		}

   161

	}

   162

}

   163

   164

// Draw the textmessage-box

   165

void DrawTextMessage(void)

   166

{

   167

	int i, j;

   168

	bool has_message;

   169

   170

	if (!_textmessage_dirty)

   171

		return;

   172

   173

	// First undraw if needed

   174

	UndrawTextMessage();

   175

   176

	if (_iconsole_mode == ICONSOLE_FULL)

   177

		return;

   178

   179

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

   180

	has_message = false;

   181

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

   182

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

   183

			break;

   184

   185

		has_message = true;

   186

	}

   187

	if (!has_message)

   188

		return;

   189

   190

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

   191

	memcpy_pitch(

   192

		_textmessage_backup,

   193

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

   194

		_textmessage_width, _textmessage_box_y, _screen.pitch, _textmessage_width);

   195

   196

	// Switch to _screen painting

   197

	_cur_dpi = &_screen;

   198

   199

	j = 0;

   200

	// Paint the messages

   201

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

   202

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

   203

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

   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 != 0xFFFF; ) {

   239

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

   240

			return;

   241

	}

   242

   243

	te->string_id = msg;

   244

	te->duration = duration;

   245

	te->y = y - 5;

   246

	te->bottom = y + 5;

   247

	te->params_1 = GetDParam(0);

   248

	te->params_2 = GetDParam(4);

   249

   250

	GetString(buffer, msg);

   251

	w = GetStringWidth(buffer);

   252

   253

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

   254

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

   255

	MarkTextEffectAreaDirty(te);

   256

}

   257

   258

static void MoveTextEffect(TextEffect *te)

   259

{

   260

	if (te->duration < 8) {

   261

		te->string_id = 0xFFFF;

   262

	} else {

   263

		te->duration-=8;

   264

		te->y--;

   265

		te->bottom--;

   266

	}

   267

	MarkTextEffectAreaDirty(te);

   268

}

   269

   270

void MoveAllTextEffects(void)

   271

{

   272

	TextEffect *te;

   273

   274

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

   275

		if (te->string_id != 0xFFFF)

   276

			MoveTextEffect(te);

   277

	}

   278

}

   279

   280

void InitTextEffects(void)

   281

{

   282

	TextEffect *te;

   283

   284

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

   285

		te->string_id = 0xFFFF;

   286

	}

   287

}

   288

   289

void DrawTextEffects(DrawPixelInfo *dpi)

   290

{

   291

	TextEffect *te;

   292

   293

	if (dpi->zoom < 1) {

   294

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

   295

			if (te->string_id == 0xFFFF)

   296

				continue;

   297

   298

			/* intersection? */

   299

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

   300

					dpi->top > te->bottom ||

   301

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

   302

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

   303

						continue;

   304

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

   305

		}

   306

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

   307

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

   308

			if (te->string_id == 0xFFFF)

   309

				continue;

   310

   311

			/* intersection? */

   312

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

   313

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

   314

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

   315

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

   316

						continue;

   317

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

   318

		}

   319

   320

	}

   321

}

   322

   323

void DeleteAnimatedTile(TileIndex tile)

   324

{

   325

	TileIndex *ti;

   326

   327

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

   328

		if (tile == *ti) {

   329

			/* remove the hole */

   330

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

   331

			/* and clear last item */

   332

			endof(_animated_tile_list)[-1] = 0;

   333

			MarkTileDirtyByTile(tile);

   334

			return;

   335

		}

   336

	}

   337

}

   338

   339

bool AddAnimatedTile(TileIndex tile)

   340

{

   341

	TileIndex *ti;

   342

   343

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

   344

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

   345

			*ti = tile;

   346

			MarkTileDirtyByTile(tile);

   347

			return true;

   348

		}

   349

	}

   350

   351

	return false;

   352

}

   353

   354

void AnimateAnimatedTiles(void)

   355

{

   356

	TileIndex *ti;

   357

	TileIndex tile;

   358

   359

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

   360

		AnimateTile(tile);

   361

	}

   362

}

   363

   364

void InitializeAnimatedTiles(void)

   365

{

   366

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

   367

}

   368

   369

static void SaveLoad_ANIT(void)

   370

{

   371

	if (_sl.version < 6) {

   372

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

   373

	} else

   374

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

   375

}

   376

   377

   378

const ChunkHandler _animated_tile_chunk_handlers[] = {

   379

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

   380

};

   381

   382