signs.cpp

Go to the documentation of this file.

/* $Id: signs.cpp 14422 2008-09-30 20:51:04Z rubidium $ */

#include "stdafx.h"
#include "openttd.h"
#include "landscape.h"
#include "company_func.h"
#include "signs_base.h"
#include "signs_func.h"
#include "saveload.h"
#include "command_func.h"
#include "variables.h"
#include "strings_func.h"
#include "viewport_func.h"
#include "tilehighlight_func.h"
#include "zoom_func.h"
#include "functions.h"
#include "window_func.h"
#include "map_func.h"
#include "string_func.h"
#include "oldpool_func.h"

#include "table/strings.h"

SignID _new_sign_id;

/* Initialize the sign-pool */
DEFINE_OLD_POOL_GENERIC(Sign, Sign)

Sign::Sign(Owner owner)
{
  this->owner = owner;
}

Sign::~Sign()
{
  free(this->name);

  if (CleaningPool()) return;

  DeleteRenameSignWindow(this->index);
  this->owner = INVALID_OWNER;
}

static void UpdateSignVirtCoords(Sign *si)
{
  Point pt = RemapCoords(si->x, si->y, si->z);
  SetDParam(0, si->index);
  UpdateViewportSignPos(&si->sign, pt.x, pt.y - 6, STR_2806);
}

void UpdateAllSignVirtCoords()
{
  Sign *si;

  FOR_ALL_SIGNS(si) UpdateSignVirtCoords(si);

}

static void MarkSignDirty(Sign *si)
{
  /* We use ZOOM_LVL_MAX here, as every viewport can have an other zoom,
    *  and there is no way for us to know which is the biggest. So make the
    *  biggest area dirty, and we are safe for sure. */
  MarkAllViewportsDirty(
    si->sign.left - 6,
    si->sign.top  - 3,
    si->sign.left + ScaleByZoom(si->sign.width_1 + 12, ZOOM_LVL_MAX),
    si->sign.top  + ScaleByZoom(12, ZOOM_LVL_MAX));
}

CommandCost CmdPlaceSign(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  /* Try to locate a new sign */
  if (!Sign::CanAllocateItem()) return_cmd_error(STR_2808_TOO_MANY_SIGNS);

  /* When we execute, really make the sign */
  if (flags & DC_EXEC) {
    Sign *si = new Sign(_current_company);
    int x = TileX(tile) * TILE_SIZE;
    int y = TileY(tile) * TILE_SIZE;

    si->x = x;
    si->y = y;
    si->z = GetSlopeZ(x, y);
    UpdateSignVirtCoords(si);
    MarkSignDirty(si);
    InvalidateWindowData(WC_SIGN_LIST, 0, 0);
    _new_sign_id = si->index;
  }

  return CommandCost();
}

CommandCost CmdRenameSign(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  if (!IsValidSignID(p1)) return CMD_ERROR;

  /* If _cmd_text 0 means the new text for the sign is non-empty.
   * So rename the sign. If it is empty, it has no name, so delete it */
  if (!StrEmpty(_cmd_text)) {
    if (strlen(_cmd_text) >= MAX_LENGTH_SIGN_NAME_BYTES) return CMD_ERROR;

    if (flags & DC_EXEC) {
      Sign *si = GetSign(p1);

      /* Delete the old name */
      free(si->name);
      /* Assign the new one */
      si->name = strdup(_cmd_text);
      si->owner = _current_company;

      /* Update; mark sign dirty twice, because it can either becom longer, or shorter */
      MarkSignDirty(si);
      UpdateSignVirtCoords(si);
      MarkSignDirty(si);
      InvalidateWindowData(WC_SIGN_LIST, 0, 1);
    }
  } else { // Delete sign
    if (flags & DC_EXEC) {
      Sign *si = GetSign(p1);

      MarkSignDirty(si);
      delete si;

      InvalidateWindowData(WC_SIGN_LIST, 0, 0);
    }
  }

  return CommandCost();
}

void CcPlaceSign(bool success, TileIndex tile, uint32 p1, uint32 p2)
{
  if (success) {
    ShowRenameSignWindow(GetSign(_new_sign_id));
    ResetObjectToPlace();
  }
}

void PlaceProc_Sign(TileIndex tile)
{
  DoCommandP(tile, 0, 0, CcPlaceSign, CMD_PLACE_SIGN | CMD_MSG(STR_2809_CAN_T_PLACE_SIGN_HERE));
}

void InitializeSigns()
{
  _Sign_pool.CleanPool();
  _Sign_pool.AddBlockToPool();
}

static const SaveLoad _sign_desc[] = {
  SLE_CONDVAR(Sign, name,  SLE_NAME,                   0, 83),
  SLE_CONDSTR(Sign, name,  SLE_STR, 0,                84, SL_MAX_VERSION),
  SLE_CONDVAR(Sign, x,     SLE_FILE_I16 | SLE_VAR_I32, 0, 4),
  SLE_CONDVAR(Sign, y,     SLE_FILE_I16 | SLE_VAR_I32, 0, 4),
  SLE_CONDVAR(Sign, x,     SLE_INT32,                  5, SL_MAX_VERSION),
  SLE_CONDVAR(Sign, y,     SLE_INT32,                  5, SL_MAX_VERSION),
  SLE_CONDVAR(Sign, owner, SLE_UINT8,                  6, SL_MAX_VERSION),
      SLE_VAR(Sign, z,     SLE_UINT8),
  SLE_END()
};

static void Save_SIGN()
{
  Sign *si;

  FOR_ALL_SIGNS(si) {
    SlSetArrayIndex(si->index);
    SlObject(si, _sign_desc);
  }
}

static void Load_SIGN()
{
  int index;
  while ((index = SlIterateArray()) != -1) {
    Sign *si = new (index) Sign();
    SlObject(si, _sign_desc);
  }
}

extern const ChunkHandler _sign_chunk_handlers[] = {
  { 'SIGN', Save_SIGN, Load_SIGN, CH_ARRAY | CH_LAST},
};