newgrf_act6.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 "newgrf_bytereader.h"
#include "newgrf_internal.h"
 
#include "../safeguards.h"
 
std::map<GRFLocation, std::pair<SpriteID, uint16_t>> _grm_sprites;
GRFLineToSpriteOverride _grf_line_to_action6_sprite_override;
 
/* Action 0x06 */
static void CfgApply(ByteReader &buf)
{
  /* <06> <param-num> <param-size> <offset> ... <FF>
   *
   * B param-num     Number of parameter to substitute (First = "zero")
   *                 Ignored if that parameter was not specified in newgrf.cfg
   * B param-size    How many bytes to replace.  If larger than 4, the
   *                 bytes of the following parameter are used.  In that
   *                 case, nothing is applied unless *all* parameters
   *                 were specified.
   * B offset        Offset into data from beginning of next sprite
   *                 to place where parameter is to be stored. */
 
  /* Preload the next sprite */
  SpriteFile &file = *_cur_gps.file;
  size_t pos = file.GetPos();
  uint32_t num = file.GetContainerVersion() >= 2 ? file.ReadDword() : file.ReadWord();
  uint8_t type = file.ReadByte();
 
  /* Check if the sprite is a pseudo sprite. We can't operate on real sprites. */
  if (type != 0xFF) {
    GrfMsg(2, "CfgApply: Ignoring (next sprite is real, unsupported)");
 
    /* Reset the file position to the start of the next sprite */
    file.SeekTo(pos, SEEK_SET);
    return;
  }
 
  /* Get (or create) the override for the next sprite. */
  GRFLocation location(_cur_gps.grfconfig->ident.grfid, _cur_gps.nfo_line + 1);
  std::vector<uint8_t> &preload_sprite = _grf_line_to_action6_sprite_override[location];
 
  /* Load new sprite data if it hasn't already been loaded. */
  if (preload_sprite.empty()) {
    preload_sprite.resize(num);
    file.ReadBlock(preload_sprite.data(), num);
  }
 
  /* Reset the file position to the start of the next sprite */
  file.SeekTo(pos, SEEK_SET);
 
  /* Now perform the Action 0x06 on our data. */
  for (;;) {
    /* Read the parameter to apply. 0xFF indicates no more data to change. */
    uint param_num = buf.ReadByte();
    if (param_num == 0xFF) break;
 
    /* Get the size of the parameter to use. If the size covers multiple
     * double words, sequential parameter values are used. */
    uint param_size = buf.ReadByte();
 
    /* Bit 7 of param_size indicates we should add to the original value
     * instead of replacing it. */
    bool add_value = HasBit(param_size, 7);
    param_size = GB(param_size, 0, 7);
 
    /* Where to apply the data to within the pseudo sprite data. */
    uint offset = buf.ReadExtendedByte();
 
    /* If the parameter is a GRF parameter (not an internal variable) check
     * if it (and all further sequential parameters) has been defined. */
    if (param_num < 0x80 && (param_num + (param_size - 1) / 4) >= std::size(_cur_gps.grffile->param)) {
      GrfMsg(2, "CfgApply: Ignoring (param {} not set)", (param_num + (param_size - 1) / 4));
      break;
    }
 
    GrfMsg(8, "CfgApply: Applying {} bytes from parameter 0x{:02X} at offset 0x{:04X}", param_size, param_num, offset);
 
    bool carry = false;
    for (uint i = 0; i < param_size && offset + i < num; i++) {
      uint32_t value = GetParamVal(param_num + i / 4, nullptr);
      /* Reset carry flag for each iteration of the variable (only really
       * matters if param_size is greater than 4) */
      if (i % 4 == 0) carry = false;
 
      if (add_value) {
        uint new_value = preload_sprite[offset + i] + GB(value, (i % 4) * 8, 8) + (carry ? 1 : 0);
        preload_sprite[offset + i] = GB(new_value, 0, 8);
        /* Check if the addition overflowed */
        carry = new_value >= 256;
      } else {
        preload_sprite[offset + i] = GB(value, (i % 4) * 8, 8);
      }
    }
  }
}

template <> void GrfActionHandler<0x06>::FileScan(ByteReader &) { }
template <> void GrfActionHandler<0x06>::SafetyScan(ByteReader &) { }
template <> void GrfActionHandler<0x06>::LabelScan(ByteReader &) { }
template <> void GrfActionHandler<0x06>::Init(ByteReader &buf) { CfgApply(buf); }
template <> void GrfActionHandler<0x06>::Reserve(ByteReader &buf) { CfgApply(buf); }
template <> void GrfActionHandler<0x06>::Activation(ByteReader &buf) { CfgApply(buf); }