1

/* $Id$ */

     2

     3

/** @file signs.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "table/strings.h"

     8

#include "strings.h"

     9

#include "functions.h"

    10

#include "landscape.h"

    11

#include "player.h"

    12

#include "signs.h"

    13

#include "saveload.h"

    14

#include "command.h"

    15

#include "variables.h"

    16

#include "misc/autoptr.hpp"

    17

    18

SignID _new_sign_id;

    19

uint _total_signs;

    20

    21

/* Initialize the sign-pool */

    22

DEFINE_OLD_POOL_GENERIC(Sign, Sign)

    23

    24

Sign::Sign(StringID string)

    25

{

    26

	this->str = string;

    27

}

    28

    29

Sign::~Sign()

    30

{

    31

	DeleteName(this->str);

    32

	this->str = STR_NULL;

    33

}

    34

    35

/**

    36

 *

    37

 * Update the coordinate of one sign

    38

 * @param si Pointer to the Sign

    39

 *

    40

 */

    41

static void UpdateSignVirtCoords(Sign *si)

    42

{

    43

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

    44

	SetDParam(0, si->index);

    45

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

    46

}

    47

    48

/**

    49

 *

    50

 * Update the coordinates of all signs

    51

 *

    52

 */

    53

void UpdateAllSignVirtCoords()

    54

{

    55

	Sign *si;

    56

    57

	FOR_ALL_SIGNS(si) UpdateSignVirtCoords(si);

    58

    59

}

    60

    61

/**

    62

 *

    63

 * Marks the region of a sign as dirty

    64

 *

    65

 * @param si Pointer to the Sign

    66

 */

    67

static void MarkSignDirty(Sign *si)

    68

{

    69

	/* We use ZOOM_LVL_MAX here, as every viewport can have an other zoom,

    70

		*  and there is no way for us to know which is the biggest. So make the

    71

		*  biggest area dirty, and we are safe for sure. */

    72

	MarkAllViewportsDirty(

    73

		si->sign.left - 6,

    74

		si->sign.top  - 3,

    75

		si->sign.left + ScaleByZoom(si->sign.width_1 + 12, ZOOM_LVL_MAX),

    76

		si->sign.top  + ScaleByZoom(12, ZOOM_LVL_MAX));

    77

}

    78

    79

/**

    80

 * Place a sign at the given coordinates. Ownership of sign has

    81

 * no effect whatsoever except for the colour the sign gets for easy recognition,

    82

 * but everybody is able to rename/remove it.

    83

 * @param tile tile to place sign at

    84

 * @param flags type of operation

    85

 * @param p1 unused

    86

 * @param p2 unused

    87

 */

    88

CommandCost CmdPlaceSign(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

    89

{

    90

	/* Try to locate a new sign */

    91

	Sign *si = new Sign(STR_280A_SIGN);

    92

	if (si == NULL) return_cmd_error(STR_2808_TOO_MANY_SIGNS);

    93

	AutoPtrT<Sign> s_auto_delete = si;

    94

    95

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

    96

	if (flags & DC_EXEC) {

    97

		int x = TileX(tile) * TILE_SIZE;

    98

		int y = TileY(tile) * TILE_SIZE;

    99

   100

		si->x = x;

   101

		si->y = y;

   102

		si->owner = _current_player; // owner of the sign; just eyecandy

   103

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

   104

		UpdateSignVirtCoords(si);

   105

		MarkSignDirty(si);

   106

		InvalidateWindow(WC_SIGN_LIST, 0);

   107

		_sign_sort_dirty = true;

   108

		_new_sign_id = si->index;

   109

		_total_signs++;

   110

		s_auto_delete.Detach();

   111

	}

   112

   113

	return CommandCost();

   114

}

   115

   116

/** Rename a sign. If the new name of the sign is empty, we assume

   117

 * the user wanted to delete it. So delete it. Ownership of signs

   118

 * has no meaning/effect whatsoever except for eyecandy

   119

 * @param tile unused

   120

 * @param flags type of operation

   121

 * @param p1 index of the sign to be renamed/removed

   122

 * @param p2 unused

   123

 * @return 0 if succesfull, otherwise CMD_ERROR

   124

 */

   125

CommandCost CmdRenameSign(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   126

{

   127

	if (!IsValidSignID(p1)) return CMD_ERROR;

   128

   129

	/* If _cmd_text 0 means the new text for the sign is non-empty.

   130

	 * So rename the sign. If it is empty, it has no name, so delete it */

   131

	if (_cmd_text[0] != '\0') {

   132

		/* Create the name */

   133

		StringID str = AllocateName(_cmd_text, 0);

   134

		if (str == 0) return CMD_ERROR;

   135

   136

		if (flags & DC_EXEC) {

   137

			Sign *si = GetSign(p1);

   138

   139

			/* Delete the old name */

   140

			DeleteName(si->str);

   141

			/* Assign the new one */

   142

			si->str = str;

   143

			si->owner = _current_player;

   144

   145

			/* Update; mark sign dirty twice, because it can either becom longer, or shorter */

   146

			MarkSignDirty(si);

   147

			UpdateSignVirtCoords(si);

   148

			MarkSignDirty(si);

   149

			InvalidateWindow(WC_SIGN_LIST, 0);

   150

			_sign_sort_dirty = true;

   151

		} else {

   152

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

   153

			DeleteName(str);

   154

		}

   155

	} else { // Delete sign

   156

		if (flags & DC_EXEC) {

   157

			Sign *si = GetSign(p1);

   158

   159

			MarkSignDirty(si);

   160

			delete si;

   161

   162

			InvalidateWindow(WC_SIGN_LIST, 0);

   163

			_sign_sort_dirty = true;

   164

			_total_signs--;

   165

		}

   166

	}

   167

   168

	return CommandCost();

   169

}

   170

   171

/**

   172

 * Callback function that is called after a sign is placed

   173

 * @param success of the operation

   174

 * @param tile unused

   175

 * @param p1 unused

   176

 * @param p2 unused

   177

 */

   178

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

   179

{

   180

	if (success) {

   181

		ShowRenameSignWindow(GetSign(_new_sign_id));

   182

		ResetObjectToPlace();

   183

	}

   184

}

   185

   186

/**

   187

 *

   188

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

   189

 *  sign-tool is selected

   190

 * @param tile on which to place the sign

   191

 */

   192

void PlaceProc_Sign(TileIndex tile)

   193

{

   194

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

   195

}

   196

   197

/**

   198

 *

   199

 * Initialize the signs

   200

 *

   201

 */

   202

void InitializeSigns()

   203

{

   204

	_total_signs = 0;

   205

	_Sign_pool.CleanPool();

   206

	_Sign_pool.AddBlockToPool();

   207

}

   208

   209

static const SaveLoad _sign_desc[] = {

   210

      SLE_VAR(Sign, str,   SLE_UINT16),

   211

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

   212

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

   213

  SLE_CONDVAR(Sign, x,     SLE_INT32,                  5, SL_MAX_VERSION),

   214

  SLE_CONDVAR(Sign, y,     SLE_INT32,                  5, SL_MAX_VERSION),

   215

  SLE_CONDVAR(Sign, owner, SLE_UINT8,                  6, SL_MAX_VERSION),

   216

      SLE_VAR(Sign, z,     SLE_UINT8),

   217

	SLE_END()

   218

};

   219

   220

/**

   221

 *

   222

 * Save all signs

   223

 *

   224

 */

   225

static void Save_SIGN()

   226

{

   227

	Sign *si;

   228

   229

	FOR_ALL_SIGNS(si) {

   230

		SlSetArrayIndex(si->index);

   231

		SlObject(si, _sign_desc);

   232

	}

   233

}

   234

   235

/**

   236

 *

   237

 * Load all signs

   238

 *

   239

 */

   240

static void Load_SIGN()

   241

{

   242

	_total_signs = 0;

   243

	int index;

   244

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

   245

		Sign *si = new (index) Sign();

   246

		SlObject(si, _sign_desc);

   247

   248

		_total_signs++;

   249

	}

   250

   251

	_sign_sort_dirty = true;

   252

}

   253

   254

extern const ChunkHandler _sign_chunk_handlers[] = {

   255

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

   256

};