newgrf_badge.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 "newgrf.h"
#include "newgrf_badge.h"
#include "newgrf_badge_type.h"
#include "newgrf_spritegroup.h"
#include "stringfilter_type.h"
#include "strings_func.h"
#include "timer/timer_game_calendar.h"
 
#include "table/strings.h"
 
#include "safeguards.h"
 
static constexpr char BADGE_CLASS_SEPARATOR = '/';
 
class Badges {
public:
  std::vector<BadgeID> classes; 
  std::vector<Badge> specs; 
};
class Badges {…};
 
static Badges _badges = {};
 
std::span<const Badge> GetBadges()
{
  return _badges.specs;
}
std::span<const Badge> GetBadges() {…}
 
std::span<const BadgeID> GetClassBadges()
{
  return _badges.classes;
}
std::span<const BadgeID> GetClassBadges() {…}
 
static BadgeClassID GetOrCreateBadgeClass(BadgeID index)
{
  auto it = std::ranges::find(_badges.classes, index);
  if (it == std::end(_badges.classes)) {
    it = _badges.classes.emplace(it, index);
  }
 
  return static_cast<BadgeClassID>(std::distance(std::begin(_badges.classes), it));
}
static BadgeClassID GetOrCreateBadgeClass(BadgeID index) {…}
 
void ResetBadges()
{
  _badges = {};
}
void ResetBadges() {…}
 
Badge &GetOrCreateBadge(std::string_view label)
{
  /* Check if the label exists. */
  auto it = std::ranges::find(_badges.specs, label, &Badge::label);
  if (it != std::end(_badges.specs)) return *it;
 
  BadgeClassID class_index;
 
  /* Extract class. */
  auto sep = label.find_first_of(BADGE_CLASS_SEPARATOR);
  if (sep != std::string_view::npos) {
    /* There is a separator, find (and create if necessary) the class label. */
    class_index = GetOrCreateBadge(label.substr(0, sep)).class_index;
    it = std::end(_badges.specs);
  }
 
  BadgeID index = BadgeID(std::distance(std::begin(_badges.specs), it));
  if (sep == std::string_view::npos) {
    /* There is no separator, so this badge is a class badge. */
    class_index = GetOrCreateBadgeClass(index);
  }
 
  it = _badges.specs.emplace(it, label, index, class_index);
  return *it;
}
Badge &GetOrCreateBadge(std::string_view label) {…}
 
Badge *GetBadge(BadgeID index)
{
  if (index.base() >= std::size(_badges.specs)) return nullptr;
  return &_badges.specs[index.base()];
}
Badge *GetBadge(BadgeID index) {…}
 
Badge *GetBadgeByLabel(std::string_view label)
{
  auto it = std::ranges::find(_badges.specs, label, &Badge::label);
  if (it == std::end(_badges.specs)) return nullptr;
 
  return &*it;
}
Badge *GetBadgeByLabel(std::string_view label) {…}
 
Badge *GetClassBadge(BadgeClassID class_index)
{
  if (class_index.base() >= std::size(_badges.classes)) return nullptr;
  return GetBadge(_badges.classes[class_index.base()]);
}
Badge *GetClassBadge(BadgeClassID class_index) {…}
 
struct BadgeScopeResolver : public ScopeResolver {
  const Badge &badge;
  const std::optional<TimerGameCalendar::Date> introduction_date;
 
  BadgeScopeResolver(ResolverObject &ro, const Badge &badge, const std::optional<TimerGameCalendar::Date> introduction_date)
    : ScopeResolver(ro), badge(badge), introduction_date(introduction_date) { }
  BadgeScopeResolver(ResolverObject &ro, const Badge &badge, const std::optional<TimerGameCalendar::Date> introduction_date) {…}
 
  uint32_t GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const override;
};
struct BadgeScopeResolver : public ScopeResolver {…};
 
/* virtual */ uint32_t BadgeScopeResolver::GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const
{
  switch (variable) {
    case 0x40:
      if (this->introduction_date.has_value()) return this->introduction_date->base();
      return TimerGameCalendar::date.base();
 
    default: break;
  }
 
  available = false;
  return UINT_MAX;
}
/* virtual */ uint32_t BadgeScopeResolver::GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const {…}
 
struct BadgeResolverObject : public ResolverObject {
  BadgeScopeResolver self_scope;
 
  BadgeResolverObject(const Badge &badge, GrfSpecFeature feature, std::optional<TimerGameCalendar::Date> introduction_date, CallbackID callback = CBID_NO_CALLBACK, uint32_t callback_param1 = 0, uint32_t callback_param2 = 0);
 
  ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, uint8_t relative = 0) override
  {
    switch (scope) {
      case VSG_SCOPE_SELF: return &this->self_scope;
      default: return ResolverObject::GetScope(scope, relative);
    }
  }
  ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, uint8_t relative = 0) override {…}
 
  GrfSpecFeature GetFeature() const override;
  uint32_t GetDebugID() const override;
};
struct BadgeResolverObject : public ResolverObject {…};
 
GrfSpecFeature BadgeResolverObject::GetFeature() const
{
  return GSF_BADGES;
}
GrfSpecFeature BadgeResolverObject::GetFeature() const {…}
 
uint32_t BadgeResolverObject::GetDebugID() const
{
  return this->self_scope.badge.index.base();
}
uint32_t BadgeResolverObject::GetDebugID() const {…}
 
BadgeResolverObject::BadgeResolverObject(const Badge &badge, GrfSpecFeature feature, std::optional<TimerGameCalendar::Date> introduction_date, CallbackID callback, uint32_t callback_param1, uint32_t callback_param2)
    : ResolverObject(badge.grf_prop.grffile, callback, callback_param1, callback_param2), self_scope(*this, badge, introduction_date)
{
  assert(feature <= GSF_END);
  this->root_spritegroup = this->self_scope.badge.grf_prop.GetFirstSpriteGroupOf({feature, GSF_DEFAULT});
}
BadgeResolverObject::BadgeResolverObject(const Badge &badge, GrfSpecFeature feature, std::optional<TimerGameCalendar::Date> introduction_date, CallbackID callback, uint32_t callback_param1, uint32_t callback_param2) {…}
 
uint32_t GetBadgeVariableResult(const GRFFile &grffile, std::span<const BadgeID> badges, uint32_t parameter)
{
  if (parameter >= std::size(grffile.badge_list)) return UINT_MAX;
 
  BadgeID index = grffile.badge_list[parameter];
  return std::ranges::find(badges, index) != std::end(badges);
}
uint32_t GetBadgeVariableResult(const GRFFile &grffile, std::span<const BadgeID> badges, uint32_t parameter) {…}
 
void MarkBadgeSeen(BadgeID index, GrfSpecFeature feature)
{
  Badge *b = GetBadge(index);
  assert(b != nullptr);
  b->features.Set(feature);
}
void MarkBadgeSeen(BadgeID index, GrfSpecFeature feature) {…}
 
void AppendCopyableBadgeList(std::vector<BadgeID> &dst, std::span<const BadgeID> src, GrfSpecFeature feature)
{
  for (const BadgeID &index : src) {
    /* Is badge already present? */
    if (std::ranges::find(dst, index) != std::end(dst)) continue;
 
    /* Is badge copyable? */
    Badge *badge = GetBadge(index);
    if (badge == nullptr) continue;
    if (!badge->flags.Test(BadgeFlag::Copy)) continue;
 
    dst.push_back(index);
    badge->features.Set(feature);
  }
}
void AppendCopyableBadgeList(std::vector<BadgeID> &dst, std::span<const BadgeID> src, GrfSpecFeature feature) {…}
 
void ApplyBadgeFeaturesToClassBadges()
{
  for (const Badge &badge : GetBadges()) {
    Badge *class_badge = GetClassBadge(badge.class_index);
    assert(class_badge != nullptr);
    class_badge->features.Set(badge.features);
    if (badge.name != STR_NULL) class_badge->flags.Set(BadgeFlag::HasText);
  }
}
void ApplyBadgeFeaturesToClassBadges() {…}
 
PalSpriteID GetBadgeSprite(const Badge &badge, GrfSpecFeature feature, std::optional<TimerGameCalendar::Date> introduction_date, PaletteID remap)
{
  BadgeResolverObject object(badge, feature, introduction_date);
  const auto *group = object.Resolve<ResultSpriteGroup>();
  if (group == nullptr || group->num_sprites == 0) return {0, PAL_NONE};
 
  PaletteID pal = badge.flags.Test(BadgeFlag::UseCompanyColour) ? remap : PAL_NONE;
 
  return {group->sprite, pal};
}
PalSpriteID GetBadgeSprite(const Badge &badge, GrfSpecFeature feature, std::optional<TimerGameCalendar::Date> introduction_date, PaletteID remap) {…}
 
UsedBadgeClasses::UsedBadgeClasses(GrfSpecFeature feature) : feature(feature)
{
  for (auto index : _badges.classes) {
    Badge *class_badge = GetBadge(index);
    if (!class_badge->features.Test(feature)) continue;
 
    this->classes.push_back(class_badge->class_index);
  }
 
  std::ranges::sort(this->classes, [](const BadgeClassID &a, const BadgeClassID &b) { return GetClassBadge(a)->label < GetClassBadge(b)->label; });
}
UsedBadgeClasses::UsedBadgeClasses(GrfSpecFeature feature) : feature(feature) {…}
 
BadgeTextFilter::BadgeTextFilter(StringFilter &filter, GrfSpecFeature feature)
{
  /* Do not filter if the filter text box is empty */
  if (filter.IsEmpty()) return;
 
  /* Pre-build list of badges that match by string. */
  for (const auto &badge : GetBadges()) {
    if (badge.name == STR_NULL) continue;
    if (!badge.features.Test(feature)) continue;
 
    filter.ResetState();
    filter.AddLine(GetString(badge.name));
    if (!filter.GetState()) continue;
 
    this->badges.insert(badge.index);
  }
}
BadgeTextFilter::BadgeTextFilter(StringFilter &filter, GrfSpecFeature feature) {…}
 
bool BadgeTextFilter::Filter(std::span<const BadgeID> badges) const
{
  return std::ranges::any_of(badges, [this](const BadgeID &badge) { return std::ranges::binary_search(this->badges, badge); });
}
bool BadgeTextFilter::Filter(std::span<const BadgeID> badges) const {…}
 
bool BadgeDropdownFilter::Filter(std::span<const BadgeID> badges) const
{
  if (this->badges.empty()) return true;
 
  /* We want all filtered badges to match. */
  return std::ranges::all_of(this->badges, [&badges](const auto &badge) { return std::ranges::find(badges, badge.second) != std::end(badges); });
}
bool BadgeDropdownFilter::Filter(std::span<const BadgeID> badges) const {…}