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

 *

    22

 * Update the coordinates of all signs

    23

 *

    24

 */

    25

void UpdateAllSignVirtCoords(void)

    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(void)

    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

 *

    68

 * Place a sign at the given x/y

    69

 *

    70

 * @param p1 player number

    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->owner = p1;

    88

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

    89

		UpdateSignVirtCoords(ss);

    90

		MarkSignDirty(ss);

    91

		_new_sign_struct = ss;

    92

	}

    93

    94

	return 0;

    95

}

    96

    97

/**

    98

 * Rename a sign

    99

 *

   100

 * @param sign_id Index of the sign

   101

 * @param new owner, if OWNER_NONE, sign will be removed

   102

 */

   103

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

   104

{

   105

	StringID str;

   106

	SignStruct *ss;

   107

   108

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

   109

	if (GetDParam(0) != 0 && owner != OWNER_NONE) {

   110

		/* Create the name */

   111

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

   112

		if (str == 0)

   113

			return CMD_ERROR;

   114

   115

		if (flags & DC_EXEC) {

   116

			ss = GetSign(sign_id);

   117

   118

			MarkSignDirty(ss);

   119

   120

			/* Delete the old name */

   121

			DeleteName(ss->str);

   122

			/* Assign the new one */

   123

			ss->str = str;

   124

			ss->owner = owner;

   125

   126

			/* Update */

   127

			UpdateSignVirtCoords(ss);

   128

			MarkSignDirty(ss);

   129

		} else {

   130

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

   131

			DeleteName(str);

   132

		}

   133

	} else {

   134

		/* Delete sign */

   135

		if (flags & DC_EXEC) {

   136

			ss = GetSign(sign_id);

   137

   138

			/* Delete the name */

   139

			DeleteName(ss->str);

   140

			ss->str = 0;

   141

   142

			MarkSignDirty(ss);

   143

		}

   144

	}

   145

   146

	return 0;

   147

}

   148

   149

/**

   150

 *

   151

 * Callback function that is called after a sign is placed

   152

 *

   153

 */

   154

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

   155

{

   156

	if (success) {

   157

		ShowRenameSignWindow(_new_sign_struct);

   158

		ResetObjectToPlace();

   159

	}

   160

}

   161

   162

/**

   163

 *

   164

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

   165

 *  sign-tool is selected

   166

 *

   167

 */

   168

void PlaceProc_Sign(uint tile)

   169

{

   170

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

   171

}

   172

   173

/**

   174

 *

   175

 * Initialize the signs

   176

 *

   177

 */

   178

void InitializeSigns(void)

   179

{

   180

	SignStruct *s;

   181

	int i;

   182

   183

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

   184

   185

	i = 0;

   186

	FOR_ALL_SIGNS(s)

   187

		s->index = i++;

   188

}

   189

   190

static const byte _sign_desc[] = {

   191

	SLE_VAR(SignStruct,str,						SLE_UINT16),

   192

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

   193

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

   194

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

   195

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

   197

	SLE_VAR(SignStruct,z,							SLE_UINT8),

   198

	SLE_END()

   199

};

   200

   201

/**

   202

 *

   203

 * Save all signs

   204

 *

   205

 */

   206

static void Save_SIGN(void)

   207

{

   208

	SignStruct *s;

   209

   210

	FOR_ALL_SIGNS(s) {

   211

		/* Don't save empty signs */

   212

		if (s->str != 0) {

   213

			SlSetArrayIndex(s->index);

   214

			SlObject(s, _sign_desc);

   215

		}

   216

	}

   217

}

   218

   219

/**

   220

 *

   221

 * Load all signs

   222

 *

   223

 */

   224

static void Load_SIGN(void)

   225

{

   226

	int index;

   227

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

   228

		SignStruct *s = GetSign(index);

   229

   230

		SlObject(s, _sign_desc);

   231

	}

   232

}

   233

   234

const ChunkHandler _sign_chunk_handlers[] = {

   235

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

   236

};