newgrf_act0_railtypes.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#include "../stdafx.h"
#include "../debug.h"
#include "../rail.h"
#include "newgrf_bytereader.h"
#include "newgrf_internal.h"
#include "newgrf_stringmapping.h"
 
#include "../safeguards.h"

static ChangeInfoResult RailTypeChangeInfo(uint first, uint last, int prop, ByteReader &buf)
{
  ChangeInfoResult ret = ChangeInfoResult::Success;
 
  extern RailTypeInfo _railtypes[RAILTYPE_END];
  const auto &type_map = _cur_gps.grffile->railtype_map;
 
  if (last > std::size(type_map)) {
    GrfMsg(1, "RailTypeChangeInfo: Rail type {} is invalid, max {}, ignoring", last, std::size(type_map));
    return ChangeInfoResult::InvalidId;
  }
 
  for (uint id = first; id < last; ++id) {
    RailType rt = type_map[id];
    if (rt == INVALID_RAILTYPE) return ChangeInfoResult::InvalidId;
 
    RailTypeInfo *rti = &_railtypes[rt];
 
    switch (prop) {
      case 0x08: // Label of rail type
        /* Skipped here as this is loaded during reservation stage. */
        buf.ReadDWord();
        break;
 
      case 0x09: { // Toolbar caption of railtype (sets name as well for backwards compatibility for grf ver < 8)
        GRFStringID str{buf.ReadWord()};
        AddStringForMapping(str, &rti->strings.toolbar_caption);
        if (_cur_gps.grffile->grf_version < 8) {
          AddStringForMapping(str, &rti->strings.name);
        }
        break;
      }
 
      case 0x0A: // Menu text of railtype
        AddStringForMapping(GRFStringID{buf.ReadWord()}, &rti->strings.menu_text);
        break;
 
      case 0x0B: // Build window caption
        AddStringForMapping(GRFStringID{buf.ReadWord()}, &rti->strings.build_caption);
        break;
 
      case 0x0C: // Autoreplace text
        AddStringForMapping(GRFStringID{buf.ReadWord()}, &rti->strings.replace_text);
        break;
 
      case 0x0D: // New locomotive text
        AddStringForMapping(GRFStringID{buf.ReadWord()}, &rti->strings.new_loco);
        break;
 
      case 0x0E: // Compatible railtype list
      case 0x0F: // Powered railtype list
      case 0x18: // Railtype list required for date introduction
      case 0x19: // Introduced railtype list
      {
        /* Rail type compatibility bits are added to the existing bits
         * to allow multiple GRFs to modify compatibility with the
         * default rail types. */
        int n = buf.ReadByte();
        for (int j = 0; j != n; j++) {
          RailType resolved_rt = GetRailTypeByLabel(buf.ReadLabel<RailTypeLabel>(), false);
          if (resolved_rt != INVALID_RAILTYPE) {
            switch (prop) {
              case 0x0F: rti->powered_railtypes.Set(resolved_rt);               [[fallthrough]]; // Powered implies compatible.
              case 0x0E: rti->compatible_railtypes.Set(resolved_rt);            break;
              case 0x18: rti->introduction_required_railtypes.Set(resolved_rt); break;
              case 0x19: rti->introduces_railtypes.Set(resolved_rt);            break;
            }
          }
        }
        break;
      }
 
      case 0x10: // Rail Type flags
        rti->flags = static_cast<RailTypeFlags>(buf.ReadByte());
        break;
 
      case 0x11: // Curve speed advantage
        rti->curve_speed = buf.ReadByte();
        break;
 
      case 0x12: // Station graphic
        rti->fallback_railtype = Clamp(buf.ReadByte(), 0, 2);
        break;
 
      case 0x13: // Construction cost factor
        rti->cost_multiplier = buf.ReadWord();
        break;
 
      case 0x14: // Speed limit
        rti->max_speed = buf.ReadWord();
        break;
 
      case 0x15: // Acceleration model
        rti->acceleration_type = static_cast<VehicleAccelerationModel>(Clamp(buf.ReadByte(), 0, 2));
        break;
 
      case 0x16: // Map colour
        rti->map_colour = PixelColour{buf.ReadByte()};
        break;
 
      case 0x17: // Introduction date
        rti->introduction_date = TimerGameCalendar::Date(buf.ReadDWord());
        break;
 
      case 0x1A: // Sort order
        rti->sorting_order = buf.ReadByte();
        break;
 
      case 0x1B: // Name of railtype (overridden by prop 09 for grf ver < 8)
        AddStringForMapping(GRFStringID{buf.ReadWord()}, &rti->strings.name);
        break;
 
      case 0x1C: // Maintenance cost factor
        rti->maintenance_multiplier = buf.ReadWord();
        break;
 
      case 0x1D: // Alternate rail type label list
        /* Skipped here as this is loaded during reservation stage. */
        for (int j = buf.ReadByte(); j != 0; j--) buf.ReadDWord();
        break;
 
      case 0x1E: // Badge list
        rti->badges = ReadBadgeList(buf, GrfSpecFeature::RailTypes);
        break;
 
      default:
        ret = ChangeInfoResult::Unknown;
        break;
    }
  }
 
  return ret;
}
 
static ChangeInfoResult RailTypeReserveInfo(uint first, uint last, int prop, ByteReader &buf)
{
  ChangeInfoResult ret = ChangeInfoResult::Success;
 
  extern RailTypeInfo _railtypes[RAILTYPE_END];
  auto &type_map = _cur_gps.grffile->railtype_map;
 
  if (last > std::size(type_map)) {
    GrfMsg(1, "RailTypeReserveInfo: Rail type {} is invalid, max {}, ignoring", last, std::size(type_map));
    return ChangeInfoResult::InvalidId;
  }
 
  for (uint id = first; id < last; ++id) {
    switch (prop) {
      case 0x08: // Label of rail type
      {
        RailTypeLabel rtl = buf.ReadLabel<RailTypeLabel>();
        RailType rt = GetRailTypeByLabel(rtl, false);
        if (rt == INVALID_RAILTYPE) {
          /* Set up new rail type */
          rt = AllocateRailType(rtl);
        }
 
        type_map[id] = rt;
        break;
      }
 
      case 0x09: // Toolbar caption of railtype
      case 0x0A: // Menu text
      case 0x0B: // Build window caption
      case 0x0C: // Autoreplace text
      case 0x0D: // New loco
      case 0x13: // Construction cost
      case 0x14: // Speed limit
      case 0x1B: // Name of railtype
      case 0x1C: // Maintenance cost factor
        buf.ReadWord();
        break;
 
      case 0x1D: // Alternate rail type label list
        if (type_map[id] != INVALID_RAILTYPE) {
          int n = buf.ReadByte();
          for (int j = 0; j != n; j++) {
            _railtypes[type_map[id]].alternate_labels.insert(buf.ReadLabel<RailTypeLabel>());
          }
          break;
        }
        GrfMsg(1, "RailTypeReserveInfo: Ignoring property 1D for rail type {} because no label was set", id);
        [[fallthrough]];
 
      case 0x0E: // Compatible railtype list
      case 0x0F: // Powered railtype list
      case 0x18: // Railtype list required for date introduction
      case 0x19: // Introduced railtype list
        for (int j = buf.ReadByte(); j != 0; j--) buf.ReadDWord();
        break;
 
      case 0x10: // Rail Type flags
      case 0x11: // Curve speed advantage
      case 0x12: // Station graphic
      case 0x15: // Acceleration model
      case 0x16: // Map colour
      case 0x1A: // Sort order
        buf.ReadByte();
        break;
 
      case 0x17: // Introduction date
        buf.ReadDWord();
        break;
 
      case 0x1E: // Badge list
        SkipBadgeList(buf);
        break;
 
      default:
        ret = ChangeInfoResult::Unknown;
        break;
    }
  }
 
  return ret;
}

template <> ChangeInfoResult GrfChangeInfoHandler<GrfSpecFeature::RailTypes>::Reserve(uint first, uint last, int prop, ByteReader &buf) { return RailTypeReserveInfo(first, last, prop, buf); }
template <> ChangeInfoResult GrfChangeInfoHandler<GrfSpecFeature::RailTypes>::Activation(uint first, uint last, int prop, ByteReader &buf) { return RailTypeChangeInfo(first, last, prop, buf); }