autoreplace.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 <http://www.gnu.org/licenses/>.
 */
 
#include "stdafx.h"
#include "command_func.h"
#include "group.h"
#include "autoreplace_base.h"
#include "core/bitmath_func.hpp"
#include "core/pool_func.hpp"
 
#include "safeguards.h"
 
EngineRenewPool _enginerenew_pool("EngineRenew");
INSTANTIATE_POOL_METHODS(EngineRenew)
 
 
static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine, GroupID group)
{
  EngineRenew *er = (EngineRenew *)erl;
 
  while (er != nullptr) {
    if (er->from == engine && GroupIsInGroup(group, er->group_id)) return er;
    er = er->next;
  }
  return nullptr;
}
 
void RemoveAllEngineReplacement(EngineRenewList *erl)
{
  EngineRenew *er = (EngineRenew *)(*erl);
  EngineRenew *next;
 
  while (er != nullptr) {
    next = er->next;
    delete er;
    er = next;
  }
  *erl = nullptr; // Empty list
}
 
EngineID EngineReplacement(EngineRenewList erl, EngineID engine, GroupID group, bool *replace_when_old)
{
  const EngineRenew *er = GetEngineReplacement(erl, engine, group);
  if (er == nullptr && (group == DEFAULT_GROUP || (Group::IsValidID(group) && !Group::Get(group)->flags.Test(GroupFlag::ReplaceProtection)))) {
    /* We didn't find anything useful in the vehicle's own group so we will try ALL_GROUP */
    er = GetEngineReplacement(erl, engine, ALL_GROUP);
  }
  if (replace_when_old != nullptr) {
    if (er == nullptr) {
      /* Not replacing */
      *replace_when_old = false;
    } else if (er->to == engine) {
      /* When replacing with same model, only ever do it when old */
      *replace_when_old = true;
    } else {
      /* Use player setting */
      *replace_when_old = er->replace_when_old;
    }
  }
  return er == nullptr ? EngineID::Invalid() : er->to;
}
 
CommandCost AddEngineReplacement(EngineRenewList *erl, EngineID old_engine, EngineID new_engine, GroupID group, bool replace_when_old, DoCommandFlags flags)
{
  /* Check if the old vehicle is already in the list */
  EngineRenew *er = GetEngineReplacement(*erl, old_engine, group);
  if (er != nullptr) {
    if (flags.Test(DoCommandFlag::Execute)) {
      er->to = new_engine;
      er->replace_when_old = replace_when_old;
    }
    return CommandCost();
  }
 
  if (!EngineRenew::CanAllocateItem()) return CMD_ERROR;
 
  if (flags.Test(DoCommandFlag::Execute)) {
    /* Insert before the first element */
    *erl = new EngineRenew(old_engine, new_engine, group, replace_when_old, *erl);
  }
 
  return CommandCost();
}
 
CommandCost RemoveEngineReplacement(EngineRenewList *erl, EngineID engine, GroupID group, DoCommandFlags flags)
{
  EngineRenew *er = (EngineRenew *)(*erl);
  EngineRenew *prev = nullptr;
 
  while (er != nullptr) {
    if (er->from == engine && er->group_id == group) {
      if (flags.Test(DoCommandFlag::Execute)) {
        if (prev == nullptr) { // First element
          /* The second becomes the new first element */
          *erl = (EngineRenewList)er->next;
        } else {
          /* Cut this element out */
          prev->next = er->next;
        }
        delete er;
      }
      return CommandCost();
    }
    prev = er;
    er = er->next;
  }
 
  return CMD_ERROR;
}