ai_gui.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 "../error.h"
#include "../company_base.h"
#include "../window_func.h"
#include "../network/network.h"
#include "../settings_func.h"
#include "../network/network_content.h"
#include "../core/geometry_func.hpp"
 
#include "ai.hpp"
#include "ai_gui.hpp"
#include "ai_config.hpp"
#include "ai_info.hpp"
#include "../script/script_gui.h"
 
#include "../widgets/ai_widget.h"
 
#include "table/strings.h"
 
#include "../safeguards.h"
 

static constexpr std::initializer_list<NWidgetPart> _nested_ai_config_widgets = {
  NWidget(NWID_HORIZONTAL),
    NWidget(WWT_CLOSEBOX, Colours::Mauve),
    NWidget(WWT_CAPTION, Colours::Mauve), SetStringTip(STR_AI_CONFIG_CAPTION_AI, STR_TOOLTIP_WINDOW_TITLE_DRAG_THIS),
  EndContainer(),
  NWidget(WWT_PANEL, Colours::Mauve, WID_AIC_BACKGROUND),
    NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_wide, 0), SetPadding(WidgetDimensions::unscaled.sparse),
      NWidget(NWID_VERTICAL), SetPIP(0, WidgetDimensions::unscaled.vsep_sparse, 0),
        NWidget(NWID_HORIZONTAL), SetPIP(0, WidgetDimensions::unscaled.hsep_wide, 0),
          NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
            NWidget(WWT_PUSHARROWBTN, Colours::Yellow, WID_AIC_DECREASE_NUMBER), SetArrowWidgetTypeTip(ArrowWidgetType::Decrease),
            NWidget(WWT_PUSHARROWBTN, Colours::Yellow, WID_AIC_INCREASE_NUMBER), SetArrowWidgetTypeTip(ArrowWidgetType::Increase),
          EndContainer(),
          NWidget(WWT_TEXT, Colours::Invalid, WID_AIC_NUMBER), SetFill(1, 0),
        EndContainer(),
        NWidget(NWID_HORIZONTAL), SetPIP(0, WidgetDimensions::unscaled.hsep_wide, 0),
          NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
            NWidget(WWT_PUSHARROWBTN, Colours::Yellow, WID_AIC_DECREASE_INTERVAL), SetArrowWidgetTypeTip(ArrowWidgetType::Decrease),
            NWidget(WWT_PUSHARROWBTN, Colours::Yellow, WID_AIC_INCREASE_INTERVAL), SetArrowWidgetTypeTip(ArrowWidgetType::Increase),
          EndContainer(),
          NWidget(WWT_TEXT, Colours::Invalid, WID_AIC_INTERVAL), SetFill(1, 0),
        EndContainer(),
        NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
          NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_MOVE_UP), SetResize(1, 0), SetFill(1, 0), SetStringTip(STR_AI_CONFIG_MOVE_UP, STR_AI_CONFIG_MOVE_UP_TOOLTIP),
          NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_MOVE_DOWN), SetResize(1, 0), SetFill(1, 0), SetStringTip(STR_AI_CONFIG_MOVE_DOWN, STR_AI_CONFIG_MOVE_DOWN_TOOLTIP),
        EndContainer(),
      EndContainer(),
      NWidget(WWT_FRAME, Colours::Mauve), SetStringTip(STR_AI_CONFIG_AI), SetPIP(0, WidgetDimensions::unscaled.vsep_sparse, 0),
        NWidget(NWID_HORIZONTAL),
          NWidget(WWT_MATRIX, Colours::Mauve, WID_AIC_LIST), SetMinimalSize(288, 112), SetFill(1, 0), SetMatrixDataTip(1, 8, STR_AI_CONFIG_AILIST_TOOLTIP), SetScrollbar(WID_AIC_SCROLLBAR),
          NWidget(NWID_VSCROLLBAR, Colours::Mauve, WID_AIC_SCROLLBAR),
        EndContainer(),
        NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_CONFIGURE), SetFill(1, 0), SetStringTip(STR_AI_CONFIG_CONFIGURE, STR_AI_CONFIG_CONFIGURE_TOOLTIP),
      EndContainer(),
      NWidget(NWID_HORIZONTAL), SetPIP(0, WidgetDimensions::unscaled.hsep_wide, 0),
        NWidget(NWID_VERTICAL, NWidContainerFlag::EqualSize),
          NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_CHANGE), SetFill(1, 1), SetStringTip(STR_AI_CONFIG_CHANGE_AI, STR_AI_CONFIG_CHANGE_TOOLTIP),
          NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_CONTENT_DOWNLOAD), SetFill(1, 1), SetStringTip(STR_INTRO_ONLINE_CONTENT, STR_INTRO_TOOLTIP_ONLINE_CONTENT),
        EndContainer(),
        NWidget(NWID_VERTICAL, NWidContainerFlag::EqualSize),
          NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
            NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_OPEN_URL), SetResize(1, 0), SetFill(1, 0), SetStringTip(STR_CONTENT_OPEN_URL, STR_CONTENT_OPEN_URL_TOOLTIP),
            NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_TEXTFILE + TextfileType::Readme), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TEXTFILE_VIEW_README, STR_TEXTFILE_VIEW_README_TOOLTIP),
          EndContainer(),
          NWidget(NWID_HORIZONTAL, NWidContainerFlag::EqualSize),
            NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_TEXTFILE + TextfileType::Changelog), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TEXTFILE_VIEW_CHANGELOG, STR_TEXTFILE_VIEW_CHANGELOG_TOOLTIP),
            NWidget(WWT_PUSHTXTBTN, Colours::Yellow, WID_AIC_TEXTFILE + TextfileType::License), SetFill(1, 1), SetResize(1, 0), SetStringTip(STR_TEXTFILE_VIEW_LICENCE, STR_TEXTFILE_VIEW_LICENCE_TOOLTIP),
          EndContainer(),
        EndContainer(),
      EndContainer(),
    EndContainer(),
  EndContainer(),
};

static WindowDesc _ai_config_desc(
  WindowPosition::Center, {}, 0, 0,
  WindowClass::GameOptions, WindowClass::None,
  {},
  _nested_ai_config_widgets
);

struct AIConfigWindow : public Window {
  CompanyID selected_slot = CompanyID::Invalid(); 
  int line_height = 0; 
  Scrollbar *vscroll = nullptr; 
 
  AIConfigWindow() : Window(_ai_config_desc)
  {
    this->InitNested(GameOptionsWindowNumber::AI); // Initializes 'this->line_height' as a side effect.
    this->vscroll = this->GetScrollbar(WID_AIC_SCROLLBAR);
    this->selected_slot = CompanyID::Invalid();
    NWidgetCore *nwi = this->GetWidget<NWidgetCore>(WID_AIC_LIST);
    this->vscroll->SetCapacity(nwi->current_y / this->line_height);
    this->vscroll->SetCount(MAX_COMPANIES);
    this->OnInvalidateData(0);
  }
 
  void Close([[maybe_unused]] int data = 0) override
  {
    CloseWindowByClass(WindowClass::ScriptList);
    CloseWindowByClass(WindowClass::ScriptSettings);
    this->Window::Close();
  }
 
  std::string GetWidgetString(WidgetID widget, StringID stringid) const override
  {
    switch (widget) {
      case WID_AIC_NUMBER:
        return GetString(STR_AI_CONFIG_MAX_COMPETITORS, GetGameSettings().difficulty.max_no_competitors);
 
      case WID_AIC_INTERVAL:
        return GetString(STR_AI_CONFIG_COMPETITORS_INTERVAL, GetGameSettings().difficulty.competitors_interval);
 
      default:
        return this->Window::GetWidgetString(widget, stringid);
    }
  }
 
  void UpdateWidgetSize(WidgetID widget, Dimension &size, [[maybe_unused]] const Dimension &padding, [[maybe_unused]] Dimension &fill, [[maybe_unused]] Dimension &resize) override
  {
    switch (widget) {
      case WID_AIC_DECREASE_NUMBER:
      case WID_AIC_INCREASE_NUMBER:
      case WID_AIC_DECREASE_INTERVAL:
      case WID_AIC_INCREASE_INTERVAL:
        size = maxdim(size, NWidgetScrollbar::GetHorizontalDimension());
        break;
 
      case WID_AIC_LIST:
        this->line_height = GetCharacterHeight(FontSize::Normal) + padding.height;
        fill.height = resize.height = this->line_height;
        size.height = 8 * this->line_height;
        break;
    }
  }

  static bool IsEditable(CompanyID slot)
  {
    if (_game_mode != GameMode::Normal) {
      return slot > 0 && slot < MAX_COMPANIES;
    }
    return slot < MAX_COMPANIES && !Company::IsValidID(slot);
  }

  std::string GetSlotText(CompanyID cid) const
  {
    if ((_game_mode != GameMode::Normal && cid == 0) || (_game_mode == GameMode::Normal && Company::IsValidHumanID(cid))) return GetString(STR_AI_CONFIG_HUMAN_PLAYER);
    if (const AIInfo *info = AIConfig::GetConfig(cid)->GetInfo(); info != nullptr) return info->GetName();
    return GetString(STR_AI_CONFIG_RANDOM_AI);
  }

  TextColour GetSlotColour(CompanyID cid, CompanyID max_slot) const
  {
    if (this->selected_slot == cid) return TextColour::White;
    if (IsEditable(cid)) return cid < max_slot ? TextColour::Orange : TextColour::Silver;
    if (Company::IsValidAiID(cid)) return TextColour::Green;
    return TextColour::Silver;
  }
 
  void DrawWidget(const Rect &r, WidgetID widget) const override
  {
    switch (widget) {
      case WID_AIC_LIST: {
        Rect tr = r.Shrink(WidgetDimensions::scaled.matrix);
        int max_slot = GetGameSettings().difficulty.max_no_competitors;
        if (_game_mode == GameMode::Normal) {
          for (const Company *c : Company::Iterate()) {
            if (c->is_ai) max_slot--;
          }
          for (CompanyID cid = CompanyID::Begin(); cid < max_slot && cid < MAX_COMPANIES; ++cid) {
            if (Company::IsValidID(cid)) max_slot++;
          }
        } else {
          max_slot++; // Slot 0 is human
        }
        for (int i = this->vscroll->GetPosition(); this->vscroll->IsVisible(i) && i < MAX_COMPANIES; i++) {
          CompanyID cid = static_cast<CompanyID>(i);
          DrawString(tr, this->GetSlotText(cid), this->GetSlotColour(cid, static_cast<CompanyID>(max_slot)));
          tr.top += this->line_height;
        }
        break;
      }
    }
  }
 
  void OnClick([[maybe_unused]] Point pt, WidgetID widget, [[maybe_unused]] int click_count) override
  {
    if (widget >= WID_AIC_TEXTFILE && widget < WID_AIC_TEXTFILE + TextfileType::ContentEnd) {
      if (this->selected_slot == CompanyID::Invalid() || AIConfig::GetConfig(this->selected_slot) == nullptr) return;
 
      ShowScriptTextfileWindow(this, static_cast<TextfileType>(widget - WID_AIC_TEXTFILE), this->selected_slot);
      return;
    }
 
    switch (widget) {
      case WID_AIC_DECREASE_NUMBER:
      case WID_AIC_INCREASE_NUMBER: {
        int new_value;
        if (widget == WID_AIC_DECREASE_NUMBER) {
          new_value = std::max(0, GetGameSettings().difficulty.max_no_competitors - 1);
        } else {
          new_value = std::min<int>(MAX_COMPANIES - 1, GetGameSettings().difficulty.max_no_competitors + 1);
        }
        IConsoleSetSetting("difficulty.max_no_competitors", new_value);
        this->InvalidateData();
        break;
      }
 
      case WID_AIC_DECREASE_INTERVAL:
      case WID_AIC_INCREASE_INTERVAL: {
        int new_value;
        if (widget == WID_AIC_DECREASE_INTERVAL) {
          new_value = std::max(static_cast<int>(MIN_COMPETITORS_INTERVAL), GetGameSettings().difficulty.competitors_interval - 1);
        } else {
          new_value = std::min(static_cast<int>(MAX_COMPETITORS_INTERVAL), GetGameSettings().difficulty.competitors_interval + 1);
        }
        IConsoleSetSetting("difficulty.competitors_interval", new_value);
        this->InvalidateData();
        break;
      }
 
      case WID_AIC_LIST: { // Select a slot
        this->selected_slot = static_cast<CompanyID>(this->vscroll->GetScrolledRowFromWidget(pt.y, this, widget));
        this->InvalidateData();
        if (click_count > 1 && IsEditable(this->selected_slot)) ShowScriptListWindow(this->selected_slot, _ctrl_pressed);
        break;
      }
 
      case WID_AIC_MOVE_UP:
        if (IsEditable(this->selected_slot) && IsEditable(static_cast<CompanyID>(this->selected_slot - 1))) {
          auto it = std::next(std::begin(GetGameSettings().script_config.ai), this->selected_slot.base());
          std::swap(*it, *std::prev(it));
          this->selected_slot = static_cast<CompanyID>(this->selected_slot - 1);
          this->vscroll->ScrollTowards(this->selected_slot.base());
          this->InvalidateData();
        }
        break;
 
      case WID_AIC_MOVE_DOWN:
        if (IsEditable(this->selected_slot) && IsEditable(static_cast<CompanyID>(this->selected_slot + 1))) {
          auto it = std::next(std::begin(GetGameSettings().script_config.ai), this->selected_slot.base());
          std::swap(*it, *std::next(it));
          ++this->selected_slot;
          this->vscroll->ScrollTowards(this->selected_slot.base());
          this->InvalidateData();
        }
        break;
 
      case WID_AIC_OPEN_URL: {
        const AIConfig *config = AIConfig::GetConfig(this->selected_slot);
        if (this->selected_slot == CompanyID::Invalid() || config == nullptr || config->GetInfo() == nullptr) return;
        OpenBrowser(config->GetInfo()->GetURL());
        break;
      }
 
      case WID_AIC_CHANGE:  // choose other AI
        if (IsEditable(this->selected_slot)) ShowScriptListWindow(this->selected_slot, _ctrl_pressed);
        break;
 
      case WID_AIC_CONFIGURE: // change the settings for an AI
        ShowScriptSettingsWindow(this->selected_slot);
        break;
 
      case WID_AIC_CONTENT_DOWNLOAD:
        if (!_network_available) {
          ShowErrorMessage(GetEncodedString(STR_NETWORK_ERROR_NOTAVAILABLE), {}, WarningLevel::Error);
        } else {
          ShowNetworkContentListWindow(nullptr, ContentType::Ai);
        }
        break;
    }
  }

  void OnInvalidateData([[maybe_unused]] int data = 0, [[maybe_unused]] bool gui_scope = true) override
  {
    if (!IsEditable(this->selected_slot) && !Company::IsValidAiID(this->selected_slot)) {
      this->selected_slot = CompanyID::Invalid();
    }
 
    if (!gui_scope) return;
 
    AIConfig *config = this->selected_slot == CompanyID::Invalid() ? nullptr : AIConfig::GetConfig(this->selected_slot);
 
    this->SetWidgetDisabledState(WID_AIC_DECREASE_NUMBER, GetGameSettings().difficulty.max_no_competitors == 0);
    this->SetWidgetDisabledState(WID_AIC_INCREASE_NUMBER, GetGameSettings().difficulty.max_no_competitors == MAX_COMPANIES - 1);
    this->SetWidgetDisabledState(WID_AIC_DECREASE_INTERVAL, GetGameSettings().difficulty.competitors_interval == MIN_COMPETITORS_INTERVAL);
    this->SetWidgetDisabledState(WID_AIC_INCREASE_INTERVAL, GetGameSettings().difficulty.competitors_interval == MAX_COMPETITORS_INTERVAL);
    this->SetWidgetDisabledState(WID_AIC_CHANGE, !IsEditable(this->selected_slot));
    this->SetWidgetDisabledState(WID_AIC_CONFIGURE, this->selected_slot == CompanyID::Invalid() || config->GetConfigList()->empty());
    this->SetWidgetDisabledState(WID_AIC_MOVE_UP, !IsEditable(this->selected_slot) || !IsEditable(static_cast<CompanyID>(this->selected_slot - 1)));
    this->SetWidgetDisabledState(WID_AIC_MOVE_DOWN, !IsEditable(this->selected_slot) || !IsEditable(static_cast<CompanyID>(this->selected_slot + 1)));
 
    this->SetWidgetDisabledState(WID_AIC_OPEN_URL, this->selected_slot == CompanyID::Invalid() || config->GetInfo() == nullptr || config->GetInfo()->GetURL().empty());
    for (TextfileType tft : EnumRange(TextfileType::ContentBegin, TextfileType::ContentEnd)) {
      this->SetWidgetDisabledState(WID_AIC_TEXTFILE + tft, this->selected_slot == CompanyID::Invalid() || !config->GetTextfile(tft, this->selected_slot).has_value());
    }
  }
};

void ShowAIConfigWindow()
{
  CloseWindowByClass(WindowClass::GameOptions);
  new AIConfigWindow();
}