1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "signs.h"

     5

#include "saveload.h"

     6

#include "command.h"

     7

     8

/**

     9

 *

    10

 * Update the coordinate of one sign

    11

 *

    12

 */

    13

static void UpdateSignVirtCoords(SignStruct *ss)

    14

{

    15

	Point pt = RemapCoords(ss->x, ss->y, ss->z);

    16

	SetDParam(0, ss->str);

    17

	UpdateViewportSignPos(&ss->sign, pt.x, pt.y - 6, STR_2806);

    18

}

    19

    20

/**

    21

 *

    23

 *

    24

 */

    25

void UpdateAllSignVirtCoords()

    26

{

    27

	SignStruct *ss;

    28

    29

	FOR_ALL_SIGNS(ss)

    30

		if (ss->str != 0)

    31

			UpdateSignVirtCoords(ss);

    32

    33

}

    34

    35

/**

    36

 *

    37

 * Marks the region of a sign as dirty

    38

 *

    39

 * @param ss Pointer to the SignStruct

    40

 */

    41

static void MarkSignDirty(SignStruct *ss)

    42

{

    43

	MarkAllViewportsDirty(

    44

		ss->sign.left - 6,

    45

		ss->sign.top  - 3,

    46

		ss->sign.left + ss->sign.width_1 * 4 + 12,

    47

		ss->sign.top  + 45);

    48

}

    49

    50

/**

    51

 *

    52

 * Allocates a new sign

    53

 *

    54

 * @return The pointer to the new sign, or NULL if there is no more free space

    55

 */

    56

static SignStruct *AllocateSign()

    57

{

    58

	SignStruct *s;

    59

	FOR_ALL_SIGNS(s)

    60

		if (s->str == 0)

    61

			return s;

    62

    63

	return NULL;

    64

}

    65

    66

/**

    67

 *

    69

 *

    70

 * @param p1 not used

    71

 * @param p2 not used

    72

 */

    73

int32 CmdPlaceSign(int x, int y, uint32 flags, uint32 p1, uint32 p2)

    74

{

    75

	SignStruct *ss;

    76

    77

	/* Try to locate a new sign */

    78

	ss = AllocateSign();

    79

	if (ss == NULL)

    80

		return_cmd_error(STR_2808_TOO_MANY_SIGNS);

    81

    82

	/* When we execute, really make the sign */

    83

	if (flags & DC_EXEC) {

    84

		ss->str = STR_280A_SIGN;

    85

		ss->x = x;

    86

		ss->y = y;

    87

		ss->z = GetSlopeZ(x,y);

    88

		UpdateSignVirtCoords(ss);

    89

		MarkSignDirty(ss);

    90

		_new_sign_struct = ss;

    91

	}

    92

    93

	return 0;

    94

}

    95

    96

/**

    97

 * Rename a sign

    98

 *

    99

 * @param sign_id Index of the sign

   100

 * @param remove  If 1, sign will be removed

   101

 */

   102

int32 CmdRenameSign(int x, int y, uint32 flags, uint32 sign_id, uint32 remove)

   103

{

   104

	StringID str;

   105

	SignStruct *ss;

   106

   107

	/* If GetDParam(0) == nothing, we delete the sign */

   108

	if (GetDParam(0) != 0 && remove != 1) {

   109

		/* Create the name */

   110

		str = AllocateName((byte*)_decode_parameters, 0);

   111

		if (str == 0)

   112

			return CMD_ERROR;

   113

   114

		if (flags & DC_EXEC) {

   115

			ss = GetSign(sign_id);

   116

   117

			MarkSignDirty(ss);

   118

   119

			/* Delete the old name */

   120

			DeleteName(ss->str);

   121

			/* Assign the new one */

   122

			ss->str = str;

   123

   124

			/* Update */

   125

			UpdateSignVirtCoords(ss);

   126

			MarkSignDirty(ss);

   127

		} else {

   128

			/* Free the name, because we did not assign it yet */

   129

			DeleteName(str);

   130

		}

   131

	} else {

   132

		/* Delete sign */

   133

		if (flags & DC_EXEC) {

   134

			ss = GetSign(sign_id);

   135

   136

			/* Delete the name */

   137

			DeleteName(ss->str);

   138

			ss->str = 0;

   139

   140

			MarkSignDirty(ss);

   141

		}

   142

	}

   143

   144

	return 0;

   145

}

   146

   147

/**

   148

 *

   149

 * Callback function that is called after a sign is placed

   150

 *

   151

 */

   152

void CcPlaceSign(bool success, uint tile, uint32 p1, uint32 p2)

   153

{

   154

	if (success) {

   155

		ShowRenameSignWindow(_new_sign_struct);

   156

		ResetObjectToPlace();

   157

	}

   158

}

   159

   160

/**

   161

 *

   162

 * PlaceProc function, called when someone pressed the button if the

   163

 *  sign-tool is selected

   164

 *

   165

 */

   166

void PlaceProc_Sign(uint tile)

   167

{

   168

	DoCommandP(tile, 0, 0, CcPlaceSign, CMD_PLACE_SIGN | CMD_MSG(STR_2809_CAN_T_PLACE_SIGN_HERE));

   169

}

   170

   171

/**

   172

 *

   173

 * Initialize the signs

   174

 *

   175

 */

   176

void InitializeSigns()

   177

{

   178

	SignStruct *s;

   179

	int i;

   180

   181

	memset(_sign_list, 0, sizeof(_sign_list[0]) * _sign_size);

   182

   183

	i = 0;

   184

	FOR_ALL_SIGNS(s)

   185

		s->index = i++;

   186

}

   187

   188

static const byte _sign_desc[] = {

   189

	SLE_VAR(SignStruct,str,						SLE_UINT16),

   190

	SLE_CONDVAR(SignStruct,x,					SLE_FILE_I16 | SLE_VAR_I32, 0, 4),

   191

	SLE_CONDVAR(SignStruct,y,					SLE_FILE_I16 | SLE_VAR_I32, 0, 4),

   192

	SLE_CONDVAR(SignStruct,x,					SLE_INT32, 5, 255),

   193

	SLE_CONDVAR(SignStruct,y,					SLE_INT32, 5, 255),

   194

	SLE_VAR(SignStruct,z,							SLE_UINT8),

   195

	SLE_END()

   196

};

   197

   198

/**

   199

 *

   200

 * Save all signs

   201

 *

   202

 */

   203

static void Save_SIGN()

   204

{

   205

	SignStruct *s;

   206

   207

	FOR_ALL_SIGNS(s) {

   208

		/* Don't save empty signs */

   209

		if (s->str != 0) {

   210

			SlSetArrayIndex(s->index);

   211

			SlObject(s, _sign_desc);

   212

		}

   213

	}

   214

}

   215

   216

/**

   217

 *

   218

 * Load all signs

   219

 *

   220

 */

   221

static void Load_SIGN()

   222

{

   223

	int index;

   224

	while ((index = SlIterateArray()) != -1) {

   225

		SignStruct *s = GetSign(index);

   226

   227

		SlObject(s, _sign_desc);

   228

	}

   229

}

   230

   231

const ChunkHandler _sign_chunk_handlers[] = {

   232

	{ 'SIGN', Save_SIGN, Load_SIGN, CH_ARRAY | CH_LAST},

   233

};