1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "window.h"

     5

#include "gui.h"

     6

#include "gfx.h"

     7

#include "player.h"

     8

#include "economy.h"

     9

    10

static uint _legend_excludebits;

    11

static uint _legend_cargobits;

    12

    13

/************************/

    14

/* GENERIC GRAPH DRAWER */

    15

/************************/

    16

    17

enum {GRAPH_NUM = 16};

    18

    19

typedef struct GraphDrawer {

    20

	uint sel; // bitmask of the players *excluded* (e.g. 11111111 means that no players are shown)

    21

	byte num_dataset;

    22

	byte num_on_x_axis;

    23

	byte month;

    24

	byte year;

    25

	bool include_neg;

    26

	byte num_vert_lines;

    27

	uint16 unk61A;

    28

	uint16 unk61C;

    29

	int left, top;

    30

	uint height;

    31

	StringID format_str_y_axis;

    32

	byte color_3, color_2, bg_line_color;

    33

	byte colors[GRAPH_NUM];

    34

	uint64 cost[GRAPH_NUM][24]; // last 2 years

    35

} GraphDrawer;

    36

    37

#define INVALID_VALUE 0x80000000

    38

    39

static void DrawGraph(GraphDrawer *gw)

    40

{

    41

    42

	int i,j,k;

    43

	uint x,y,old_x,old_y;

    44

	int color;

    45

	int right, bottom;

    46

	int num_x, num_dataset;

    47

	uint64 *row_ptr, *col_ptr;

    48

	int64 mx;

    49

	int adj_height;

    50

	uint64 y_scaling, tmp;

    51

	int64 value;

    52

	int64 cur_val;

    53

	uint sel;

    54

    55

	/* the colors and cost array of GraphDrawer must accomodate

    56

	 * both values for cargo and players. So if any are higher, quit */

    57

	assert(GRAPH_NUM >= NUM_CARGO && GRAPH_NUM >= MAX_PLAYERS);

    58

    59

	color = _color_list[gw->bg_line_color].window_color_1b;

    60

    61

	/* draw the vertical lines */

    62

	i = gw->num_vert_lines; assert(i > 0);

    63

	x = gw->left + 66;

    64

	bottom = gw->top + gw->height - 1;

    65

	do {

    66

		GfxFillRect(x, gw->top, x, bottom, color);

    67

		x += 22;

    68

	} while (--i);

    69

    70

	/* draw the horizontal lines */

    71

	i = 9;

    72

	x = gw->left + 44;

    73

	y = gw->height + gw->top;

    74

	right = gw->left + 44 + gw->num_vert_lines*22-1;

    75

    76

	do {

    77

		GfxFillRect(x, y, right, y, color);

    78

		y -= gw->height >> 3;

    79

	} while (--i);

    80

    81

	/* draw vertical edge line */

    82

	GfxFillRect(x, gw->top, x, bottom, gw->color_2);

    83

    84

	adj_height = gw->height;

    85

	if (gw->include_neg) adj_height >>= 1;

    86

    87

	/* draw horiz edge line */

    88

	y = adj_height + gw->top;

    89

	GfxFillRect(x, y, right, y, gw->color_2);

    90

    91

	/* find the max element */

    92

	if (gw->num_on_x_axis == 0)

    93

		return;

    94

    95

	num_dataset = gw->num_dataset;

    96

	assert(num_dataset > 0);

    97

    98

	row_ptr = gw->cost[0];

    99

	mx = 0;

   100

		/* bit selection for the showing of various players, base max element

   101

		 * on to-be shown player-information. This way the graph can scale */

   102

	sel = gw->sel;

   103

	do {

   104

		if (!(sel&1)) {

   105

			num_x = gw->num_on_x_axis;

   106

			assert(num_x > 0);

   107

			col_ptr = row_ptr;

   108

			do {

   109

				if (*col_ptr != INVALID_VALUE) {

   110

					mx = max64(mx, myabs64(*col_ptr));

   111

				}

   112

			} while (col_ptr++, --num_x);

   113

		}

   114

	} while (sel>>=1, row_ptr+=24, --num_dataset);

   115

   116

	/* setup scaling */

   117

	y_scaling = INVALID_VALUE;

   118

	value = adj_height * 2;

   119

   120

	if (mx > value) {

   121

		mx = (mx + 7) & ~7;

   122

		y_scaling = (((uint64) (value>>1) << 32) / mx);

   123

		value = mx;

   124

	}

   125

   126

	/* draw text strings on the y axis */

   127

	tmp = value;

   128

	if (gw->include_neg) tmp >>= 1;

   129

	x = gw->left + 45;

   130

	y = gw->top - 3;

   131

	i = 9;

   132

	do {

   133

		SetDParam(0, gw->format_str_y_axis);

   134

		SetDParam64(1, (int64)tmp);

   135

		tmp -= (value >> 3);

   136

		DrawStringRightAligned(x, y, STR_0170, gw->color_3);

   137

		y += gw->height >> 3;

   138

	} while (--i);

   139

   140

	/* draw strings on the x axis */

   141

	if (gw->month != 0xFF) {

   142

		x = gw->left + 44;

   143

		y = gw->top + gw->height + 1;

   144

		j = gw->month;

   145

		k = gw->year + MAX_YEAR_BEGIN_REAL;

   146

		i = gw->num_on_x_axis;assert(i>0);

   147

		do {

   148

			SetDParam(2, k);

   149

			SetDParam(0, j + STR_0162_JAN);

   150

			SetDParam(1, j + STR_0162_JAN + 2);

   151

			DrawString(x, y, j == 0 ? STR_016F : STR_016E, gw->color_3);

   152

   153

			j += 3;

   154

			if (j >= 12) {

   155

				j = 0;

   156

				k++;

   157

			}

   158

			x += 22;

   159

		} while (--i);

   160

	} else {

   161

		x = gw->left + 52;

   162

		y = gw->top + gw->height + 1;

   163

		j = gw->unk61A;

   164

		i = gw->num_on_x_axis;assert(i>0);

   165

		do {

   166

			SetDParam(0, j);

   167

			DrawString(x, y, STR_01CB, gw->color_3);

   168

			j += gw->unk61C;

   169

			x += 22;

   170

		} while (--i);

   171

	}

   172

   173

	/* draw lines and dots */

   174

	i = 0;

   175

	row_ptr = gw->cost[0];

   176

	sel = gw->sel; // show only selected lines. GraphDrawer qw->sel set in Graph-Legend (_legend_excludebits)

   177

	do {

   178

		if (!(sel & 1)) {

   179

			x = gw->left + 55;

   180

			j = gw->num_on_x_axis;assert(j>0);

   181

			col_ptr = row_ptr;

   182

			color = gw->colors[i];

   183

			old_y = old_x = INVALID_VALUE;

   184

			do {

   185

				cur_val = *col_ptr++;

   186

				if (cur_val != INVALID_VALUE) {

   187

					y = adj_height - BIGMULSS64(cur_val, y_scaling >> 1, 31) + gw->top;

   188

   189

					GfxFillRect(x-1, y-1, x+1, y+1, color);

   190

					if (old_x != INVALID_VALUE)

   191

						GfxDrawLine(old_x, old_y, x, y, color);

   192

   193

					old_x = x;

   194

					old_y = y;

   195

				} else {

   196

					old_x = INVALID_VALUE;

   197

				}

   198

			} while (x+=22,--j);

   199

		}

   200

	} while (sel>>=1,row_ptr+=24, ++i < gw->num_dataset);

   201

}

   202

   203

/****************/

   204

/* GRAPH LEGEND */

   205

/****************/

   206

   207

void DrawPlayerIcon(int p, int x, int y)

   208

{

   209

	DrawSprite(SPRITE_PALETTE(PLAYER_SPRITE_COLOR(p) + 0x2EB), x, y);

   210

}

   211

   212

static void GraphLegendWndProc(Window *w, WindowEvent *e)

   213

{

   214

	Player *p;

   215

   216

	switch(e->event) {

   217

	case WE_PAINT:

   218

		FOR_ALL_PLAYERS(p) {

   219

			if (!p->is_active)

   220

				SETBIT(_legend_excludebits, p->index);

   221

		}

   222

		w->click_state = ((~_legend_excludebits) << 3);

   223

		DrawWindowWidgets(w);

   224

   225

		FOR_ALL_PLAYERS(p) {

   226

			if (!p->is_active)

   227

				continue;

   228

   229

			DrawPlayerIcon(p->index, 4, 18+p->index*12);

   230

   231

			SetDParam(0, p->name_1);

   232

			SetDParam(1, p->name_2);

   233

			SetDParam(2, GetPlayerNameString(p->index, 3));

   234

			DrawString(21,17+p->index*12,STR_7021,HASBIT(_legend_excludebits, p->index) ? 0x10 : 0xC);

   235

		}

   236

		break;

   237

   238

	case WE_CLICK:

   239

		if (IS_INT_INSIDE(e->click.widget, 3, 11)) {

   240

			_legend_excludebits ^= (1 << (e->click.widget-3));

   241

			SetWindowDirty(w);

   242

			InvalidateWindow(WC_INCOME_GRAPH, 0);

   243

			InvalidateWindow(WC_OPERATING_PROFIT, 0);

   244

			InvalidateWindow(WC_DELIVERED_CARGO, 0);

   245

			InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);

   246

			InvalidateWindow(WC_COMPANY_VALUE, 0);

   247

		}

   248

		break;

   249

	}

   250

}

   251

   252

static const Widget _graph_legend_widgets[] = {

   253

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5, STR_018B_CLOSE_WINDOW},

   254

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   249,     0,    13, STR_704E_KEY_TO_COMPANY_GRAPHS, STR_018C_WINDOW_TITLE_DRAG_THIS},

   255

{     WWT_IMGBTN,   RESIZE_NONE,    14,     0,   249,    14,   113, 0x0,STR_NULL},

   256

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,    16,    27, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   257

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,    28,    39, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   258

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,    40,    51, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   259

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,    52,    63, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   260

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,    64,    75, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   261

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,    76,    87, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   262

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,    88,    99, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   263

{     WWT_IMGBTN,   RESIZE_NONE,    14,     2,   247,   100,   111, 0x0,STR_704F_CLICK_HERE_TO_TOGGLE_COMPANY},

   264

{   WIDGETS_END},

   265

};

   266

   267

static const WindowDesc _graph_legend_desc = {

   268

	-1, -1, 250, 114,

   269

	WC_GRAPH_LEGEND,0,

   270

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET,

   271

	_graph_legend_widgets,

   272

	GraphLegendWndProc

   273

};

   274

   275

static void ShowGraphLegend(void)

   276

{

   277

	AllocateWindowDescFront(&_graph_legend_desc, 0);

   278

}

   279

   280

/********************/

   281

/* OPERATING PROFIT */

   282

/********************/

   283

   284

static void SetupGraphDrawerForPlayers(GraphDrawer *gd)

   285

{

   286

	Player *p;

   287

	uint excludebits = _legend_excludebits;

   288

	int nums;

   289

	int mo,yr;

   290

   291

	// Exclude the players which aren't valid

   292

	FOR_ALL_PLAYERS(p) {

   293

		if (!p->is_active) SETBIT(excludebits,p->index);

   294

	}

   295

	gd->sel = excludebits;

   296

	gd->num_vert_lines = 24;

   297

   298

	nums = 0;

   299

	FOR_ALL_PLAYERS(p) {

   300

		if (p->is_active) nums = max(nums,p->num_valid_stat_ent);

   301

	}

   302

	gd->num_on_x_axis = min(nums,24);

   303

   304

	mo = (_cur_month/3-nums)*3;

   305

	yr = _cur_year;

   306

	while (mo < 0) {

   307

		yr--;

   308

		mo += 12;

   309

	}

   310

   311

	gd->year = yr;

   312

	gd->month = mo;

   313

}

   314

   315

static void OperatingProfitWndProc(Window *w, WindowEvent *e)

   316

{

   317

	switch(e->event) {

   318

	case WE_PAINT: {

   319

		GraphDrawer gd;

   320

		Player *p;

   321

		int i,j;

   322

		int numd;

   323

   324

		DrawWindowWidgets(w);

   325

   326

		gd.left = 2;

   327

		gd.top = 18;

   328

		gd.height = 136;

   329

		gd.include_neg = true;

   330

		gd.format_str_y_axis = STR_CURRCOMPACT32;

   331

		gd.color_3 = 0x10;

   332

		gd.color_2 = 0xD7;

   333

		gd.bg_line_color = 0xE;

   334

   335

		SetupGraphDrawerForPlayers(&gd);

   336

   337

		numd = 0;

   338

		FOR_ALL_PLAYERS(p) {

   339

			if (p->is_active) {

   340

				gd.colors[numd] = _color_list[p->player_color].window_color_bgb;

   341

				for(j=gd.num_on_x_axis,i=0; --j >= 0;) {

   342

					gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_VALUE : (uint64)(p->old_economy[j].income + p->old_economy[j].expenses);

   343

					i++;

   344

				}

   345

			}

   346

			numd++;

   347

		}

   348

   349

		gd.num_dataset = numd;

   350

   351

		DrawGraph(&gd);

   352

	}	break;

   353

	case WE_CLICK:

   354

		if (e->click.widget == 2) /* Clicked on Legend */

   355

			ShowGraphLegend();

   356

		break;

   357

	}

   358

}

   359

   360

static const Widget _operating_profit_widgets[] = {

   361

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,												STR_018B_CLOSE_WINDOW},

   362

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   525,     0,    13, STR_7025_OPERATING_PROFIT_GRAPH, STR_018C_WINDOW_TITLE_DRAG_THIS},

   363

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   526,   575,     0,    13, STR_704C_KEY,										STR_704D_SHOW_KEY_TO_GRAPHS},

   364

{     WWT_IMGBTN,   RESIZE_NONE,    14,     0,   575,    14,   173, 0x0,															STR_NULL},

   365

{   WIDGETS_END},

   366

};

   367

   368

static const WindowDesc _operating_profit_desc = {

   369

	-1, -1, 576, 174,

   370

	WC_OPERATING_PROFIT,0,

   371

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   372

	_operating_profit_widgets,

   373

	OperatingProfitWndProc

   374

};

   375

   376

   377

void ShowOperatingProfitGraph(void)

   378

{

   379

	if (AllocateWindowDescFront(&_operating_profit_desc, 0)) {

   380

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   381

	}

   382

}

   383

   384

   385

/****************/

   386

/* INCOME GRAPH */

   387

/****************/

   388

   389

static void IncomeGraphWndProc(Window *w, WindowEvent *e)

   390

{

   391

	switch(e->event) {

   392

	case WE_PAINT: {

   393

		GraphDrawer gd;

   394

		Player *p;

   395

		int i,j;

   396

		int numd;

   397

   398

		DrawWindowWidgets(w);

   399

   400

		gd.left = 2;

   401

		gd.top = 18;

   402

		gd.height = 104;

   403

		gd.include_neg = false;

   404

		gd.format_str_y_axis = STR_CURRCOMPACT32;

   405

		gd.color_3 = 0x10;

   406

		gd.color_2 = 0xD7;

   407

		gd.bg_line_color = 0xE;

   408

		SetupGraphDrawerForPlayers(&gd);

   409

   410

		numd = 0;

   411

		FOR_ALL_PLAYERS(p) {

   412

			if (p->is_active) {

   413

				gd.colors[numd] = _color_list[p->player_color].window_color_bgb;

   414

				for(j=gd.num_on_x_axis,i=0; --j >= 0;) {

   415

					gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_VALUE : (uint64)p->old_economy[j].income;

   416

					i++;

   417

				}

   418

			}

   419

			numd++;

   420

		}

   421

   422

		gd.num_dataset = numd;

   423

   424

		DrawGraph(&gd);

   425

		break;

   426

	}

   427

   428

	case WE_CLICK:

   429

		if (e->click.widget == 2)

   430

			ShowGraphLegend();

   431

		break;

   432

	}

   433

}

   434

   435

static const Widget _income_graph_widgets[] = {

   436

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,							STR_018B_CLOSE_WINDOW},

   437

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   525,     0,    13, STR_7022_INCOME_GRAPH, STR_018C_WINDOW_TITLE_DRAG_THIS},

   438

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   526,   575,     0,    13, STR_704C_KEY,					STR_704D_SHOW_KEY_TO_GRAPHS},

   439

{     WWT_IMGBTN,   RESIZE_NONE,    14,     0,   575,    14,   141, 0x0,										STR_NULL},

   440

{   WIDGETS_END},

   441

};

   442

   443

static const WindowDesc _income_graph_desc = {

   444

	-1, -1, 576, 142,

   445

	WC_INCOME_GRAPH,0,

   446

	WDF_STD_TOOLTIPS | WDF_STD_BTN | WDF_DEF_WIDGET | WDF_UNCLICK_BUTTONS,

   447

	_income_graph_widgets,

   448

	IncomeGraphWndProc

   449

};

   450

   451

void ShowIncomeGraph(void)

   452

{

   453

	if (AllocateWindowDescFront(&_income_graph_desc, 0)) {

   454

		InvalidateWindow(WC_GRAPH_LEGEND, 0);

   455

	}

   456

}

   457

   458

/*******************/

   459

/* DELIVERED CARGO */

   460

/*******************/

   461

   462

static void DeliveredCargoGraphWndProc(Window *w, WindowEvent *e)

   463

{

   464

	switch(e->event) {

   465

	case WE_PAINT: {

   466

		GraphDrawer gd;

   467

		Player *p;

   468

		int i,j;

   469

		int numd;

   470

   471

		DrawWindowWidgets(w);

   472

   473

		gd.left = 2;

   474

		gd.top = 18;

   475

		gd.height = 104;

   476

		gd.include_neg = false;

   477

		gd.format_str_y_axis = STR_7024;

   478

		gd.color_3 = 0x10;

   479

		gd.color_2 = 0xD7;

   480

		gd.bg_line_color = 0xE;

   481

		SetupGraphDrawerForPlayers(&gd);

   482

   483

		numd = 0;

   484

		FOR_ALL_PLAYERS(p) {

   485

			if (p->is_active) {

   486

				gd.colors[numd] = _color_list[p->player_color].window_color_bgb;

   487

				for(j=gd.num_on_x_axis,i=0; --j >= 0;) {

   488

					gd.cost[numd][i] = (j >= p->num_valid_stat_ent) ? INVALID_VALUE : (uint64)p->old_economy[j].delivered_cargo;

   489

					i++;

   490

				}

   491

			}

   492

			numd++;

   493

		}

   494

   495

		gd.num_dataset = numd;

   496

   497

		DrawGraph(&gd);

   498

		break;

   499

	}

   500

   501

	case WE_CLICK:

   502

		if (e->click.widget == 2)

   503

			ShowGraphLegend();

   504

		break;

   505

	}

   506

}

   507

   508

static const Widget _delivered_cargo_graph_widgets[] = {

   509

{    WWT_TEXTBTN,   RESIZE_NONE,    14,     0,    10,     0,    13, STR_00C5,													STR_018B_CLOSE_WINDOW},

   510

{    WWT_CAPTION,   RESIZE_NONE,    14,    11,   525,     0,    13, STR_7050_UNITS_OF_CARGO_DELIVERED, STR_018C_WINDOW_TITLE_DRAG_THIS},

   511

{ WWT_PUSHTXTBTN,   RESIZE_NONE,    14,   526,   575,     0,    13, STR_704C_KEY,											STR_704D_SHOW_KEY_TO_GRAPHS},

   512

{     WWT_IMGBTN,   RESIZE_NONE,    14,     0,   575,    14,   141, 0x0,																STR_NULL},