rodecomp/Source/UI/Items/UIItemRepairWnd.cpp

#include "Client/Mode/ModeMessage.h"
#include "UI/Window/WindowId.h"
#include "UI/Window/UIWindowMgr.h"
#include "UI/Window/UIEnums.h"
#include "UI/Items/UIItemRepairWnd.h"

#include "Client/Input/InputCharset.h"
#include "Client/Mode/ModeMgr.h"
#include "Client/Replay/Replay.h"
#include "Contents/Configuration/ServiceConfiguration.h"
#include "Contents/Items/ItemDescription.h"
#include "Contents/Items/ItemInfo.h"
#include "Contents/Items/ItemNaming.h"
#include "Contents/Actors/PlayerNameDictionary.h"
#include "UI/Window/WindowManagerWindows.h"
#include "Contents/Tables/MessageTable.h"
#include "UI/Items/UIMakeTargetListWnd.h"
#include "UI/Items/UIMakeTargetProcessWnd.h"
#include "UI/Items/UIMakeTargetResultWnd.h"
#include "UI/Items/UIWeaponRefineWnd.h"
#include "UI/Buttons/UIBitmapButton.h"
#include "UI/Buttons/UIButton.h"
#include "UI/Lists/UIListBox.h"

#include "Resource/MSGSTRINGID.h"
#include <cstdint>
#include <cstring>
#include <string>

#pragma pack(push, 1)
struct UIItemRepairRecordHeader {
  /* 0000 */ std::int16_t id;
  /* 0002 */ std::uint32_t bytes;

  // INLINED
  UIItemRepairRecordHeader() : id(0), bytes(0) {
  }

  // INLINED
  ~UIItemRepairRecordHeader() {
    this->bytes = 0;
    this->id = 0;
  }
};
#pragma pack(pop)

// OFFSET: 0x009A3860
// FUNCTION: fn_13609
void UIItemRepairWnd::Paint() {
  const int titleHeight = this->DrawTitleBar(true, LookupMessage(MSI_REPAIRITEMLIST), 0);
  this->DrawPanelBackground(titleHeight, 0, "");
  this->DrawButtonBar(2, 0, 1);
}

// OFFSET: 0x009A3B50
// FUNCTION: fn_13612
void UIMakeTargetResultWnd::Paint() {
  const int titleHeight = this->DrawTitleBar(false, "", 0);
  this->DrawPanelBackground(titleHeight, 0, "");
  this->DrawButtonBar(2, 0, 1);

  ITEM_INFO item;
  item.SetItemId(this->makeType);
  item.refiningLevel = 0;
  item.identified = 1;

  const int firstWidth = this->DrawFittedItemName(0x10, 2, &item, 0, 0, 0xC, 0);
  this->DrawShadowedText(firstWidth + 0x10, 2, LookupMessage(0x1AC + (this->succeeded == 1)), 0, 0, 0xFFFFFF, 0, 0xC, 0);

  const int secondWidth = this->DrawFittedItemName(0x10, 0x2A, &item, 0, 0, 0xC, 0);
  this->DrawShadowedText(secondWidth + 0x10, 0x2A, LookupMessage(this->succeeded == 1 ? 0x1AF : 0x1AE), 0, 0, 0xFFFFFF, 0, 0xC, 0);
}

// OFFSET: 0x009A0B00
// FUNCTION: fn_13604
void UIItemRepairWnd::OnCreate(int width, int height) {
  const int listWidth = width - 24;
  const int listHeight = height - 55;
  this->m_list = new UIListBox();
  this->m_list->Configure(12, 22, listWidth, listHeight, 0);
  this->m_list->backgroundRed = 240;
  this->m_list->backgroundGreen = 240;
  this->m_list->backgroundBlue = 240;
  this->m_list->SetId(184);
  this->AddChild(this->m_list);

  const std::string prefix("유저인터페이스\\");
  int positions[2][2] = {{width - 91, height - 24}, {width - 46, height - 24}};
  const char* names[2][3] = {{"btn_ok", "btn_ok_a", "btn_ok_b"}, {"btn_cancel", "btn_cancel_a", "btn_cancel_b"}};
  int ids[2] = {184, 185};

  for (int i = 0; i < 2; ++i) {
    auto* button = new UIBitmapButton();
    button->SetBitmap((prefix + names[i][0] + ".bmp").c_str(), 0, 0);
    button->SetBitmap((prefix + names[i][1] + ".bmp").c_str(), 1, 0);
    button->SetBitmap((prefix + names[i][2] + ".bmp").c_str(), 2, 0);
    button->SetSize(button->BitmapWidth(), button->BitmapHeight());
    button->Move(positions[i][0], positions[i][1]);
    button->SetId(ids[i]);
    this->AddChild(button);
  }

  this->m_message0 = 184;
}

// OFFSET: 0x009A1590
// FUNCTION: fn_13605
void UIMakeTargetListWnd::OnCreate(int width, int height) {
  const int listWidth = width - 24;
  const int listHeight = height - 55;
  this->m_list = new UIListBox();
  this->m_list->Configure(12, 22, listWidth, listHeight, 0);
  this->m_list->backgroundRed = 240;
  this->m_list->backgroundGreen = 240;
  this->m_list->backgroundBlue = 240;
  this->m_list->SetId(184);
  this->AddChild(this->m_list);

  const std::string prefix("유저인터페이스\\");
  int positions[2][2] = {{width - 91, height - 24}, {width - 46, height - 24}};
  const char* names[2][3] = {{"btn_ok", "btn_ok_a", "btn_ok_b"}, {"btn_cancel", "btn_cancel_a", "btn_cancel_b"}};
  int ids[2] = {184, 185};

  for (int i = 0; i < 2; ++i) {
    auto* button = new UIBitmapButton();
    button->SetBitmap((prefix + names[i][0] + ".bmp").c_str(), 0, 0);
    button->SetBitmap((prefix + names[i][1] + ".bmp").c_str(), 1, 0);
    button->SetBitmap((prefix + names[i][2] + ".bmp").c_str(), 2, 0);
    button->SetSize(button->BitmapWidth(), button->BitmapHeight());
    button->Move(positions[i][0], positions[i][1]);
    button->SetId(ids[i]);
    this->AddChild(button);
  }

  this->m_message0 = 184;
}

// OFFSET: 0x009A2020
// FUNCTION: fn_13606
void UIMakeTargetProcessWnd::OnCreate(int width, int height) {
  const std::string prefix("유저인터페이스\\");
  int positions[2][2] = {{width - 91, height - 24}, {width - 46, height - 24}};
  const char* names[2][3] = {{"btn_ok", "btn_ok_a", "btn_ok_b"}, {"btn_cancel", "btn_cancel_a", "btn_cancel_b"}};
  int ids[2] = {184, 185};

  for (int i = 0; i < 2; ++i) {
    auto* button = new UIBitmapButton();
    button->SetBitmap((prefix + names[i][0] + ".bmp").c_str(), 0, 0);
    button->SetBitmap((prefix + names[i][1] + ".bmp").c_str(), 1, 0);
    button->SetBitmap((prefix + names[i][2] + ".bmp").c_str(), 2, 0);
    button->SetSize(button->BitmapWidth(), button->BitmapHeight());
    button->Move(positions[i][0], positions[i][1]);
    button->SetId(ids[i]);
    this->AddChild(button);
  }

  this->m_message0 = 184;
}

// OFFSET: 0x009A29B0
// FUNCTION: fn_13607
void UIMakeTargetResultWnd::OnCreate(int width, int height) {
  const std::string prefix("유저인터페이스\\");
  const int buttonX = width - 91;
  const int buttonY = height - 24;

  auto* button = new UIBitmapButton();
  button->SetBitmap((prefix + "btn_ok" + ".bmp").c_str(), 0, 0);
  button->SetBitmap((prefix + "btn_ok_a" + ".bmp").c_str(), 1, 0);
  button->SetBitmap((prefix + "btn_ok_b" + ".bmp").c_str(), 2, 0);
  button->SetSize(button->BitmapWidth(), button->BitmapHeight());
  button->Move(buttonX, buttonY);
  button->SetId(184);
  this->AddChild(button);

  this->m_message0 = 184;
}

// OFFSET: 0x009A2DD0
// FUNCTION: fn_13608
void UIWeaponRefineWnd::OnCreate(int width, int height) {
  const int listWidth = width - 24;
  const int listHeight = height - 55;
  this->m_list = new UIListBox();
  this->m_list->Configure(12, 22, listWidth, listHeight, 0);
  this->m_list->backgroundRed = 240;
  this->m_list->backgroundGreen = 240;
  this->m_list->backgroundBlue = 240;
  this->m_list->SetId(184);
  this->AddChild(this->m_list);

  const std::string prefix("유저인터페이스\\");
  int positions[2][2] = {{width - 91, height - 24}, {width - 46, height - 24}};
  const char* names[2][3] = {{"btn_ok", "btn_ok_a", "btn_ok_b"}, {"btn_cancel", "btn_cancel_a", "btn_cancel_b"}};
  int ids[2] = {184, 185};

  for (int i = 0; i < 2; ++i) {
    auto* button = new UIBitmapButton();
    button->SetBitmap((prefix + names[i][0] + ".bmp").c_str(), 0, 0);
    button->SetBitmap((prefix + names[i][1] + ".bmp").c_str(), 1, 0);
    button->SetBitmap((prefix + names[i][2] + ".bmp").c_str(), 2, 0);
    button->SetSize(button->BitmapWidth(), button->BitmapHeight());
    button->Move(positions[i][0], positions[i][1]);
    button->SetId(ids[i]);
    this->AddChild(button);
  }

  this->m_message0 = 184;
}

// OFFSET: 0x009A3DE0
// FUNCTION: fn_13615
int UIItemRepairWnd::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::intptr_t b, std::intptr_t c, std::intptr_t d) {
  ITEM_INFO item;

  switch (message) {
  case UM_ADDITEM: {
    const UIItemRepairEntry& entry = *reinterpret_cast<const UIItemRepairEntry*>(a);
    this->entries.push_back(entry);
    this->itemIds.push_back(entry.itemId);
    this->indices.push_back(entry.index);

    item.SetItemId(entry.itemId);
    item.refiningLevel = 0;
    item.identified = 1;
    this->m_list->AddLine(item.DisplayName(0).c_str());
    return 0;
  }

  case UM_UPPUSH:
    this->m_list->SendMsg(nullptr, UM_UPPUSH, 0, 0, 0, 0);
    return 0;

  case UM_DOWNPUSH:
    this->m_list->SendMsg(nullptr, UM_DOWNPUSH, 0, 0, 0, 0);
    return 0;

  case UM_COMMAND: {
    const int response = static_cast<int>(a);
    this->RecordResponse(response, b, c, this->m_list->selected);

    switch (response) {
    case ID_OK: {
      if (g_replayAnimationScaling) {
        UIListBox* list = this->m_list;
        list->selected = static_cast<int>(d);
        list->Invalidate();
      }

      UIListBox* list = this->m_list;
      if (list->LineCount() == 0) {
        g_modeMgr.gameMode->SendMsg(MM_REPAIRITEM_SELECT_FROM_LIST, -1, 0, 0, 0);
        g_windowMgr.CloseWindow(WID_ITEMREPAIRWND);
        g_windowMgr.CloseWindow(WID_ITEMREPAIRWND);
        return 0;
      }

      const int selected = list->selected;
      if (selected >= 0) {
        for (UIItemRepairEntry& entry : this->entries) {
          if (entry.index == this->indices[selected]) {
            g_modeMgr.gameMode->SendMsg(MM_REPAIRITEM_SELECT_FROM_LIST, reinterpret_cast<int>(&entry), 0, 0, 0);
            break;
          }
        }

        g_windowMgr.CloseWindow(WID_ITEMREPAIRWND);
        return 0;
      }
      break;
    }

    case ID_CANCEL:
      g_modeMgr.gameMode->SendMsg(MM_REPAIRITEM_SELECT_FROM_LIST, -1, 0, 0, 0);
      g_windowMgr.CloseWindow(WID_ITEMREPAIRWND);
      return 0;
    }

    return 0;
  }

  case UM_REPLAY_FRAMED_DATA: {
    const auto* bytes = reinterpret_cast<const unsigned char*>(a);
    UIItemRepairRecordHeader header;
    unsigned offset = 6;
    header = *reinterpret_cast<const UIItemRepairRecordHeader*>(bytes);

    if (header.id == 22150) {
      while (static_cast<unsigned>(b) > offset) {
        header = *reinterpret_cast<const UIItemRepairRecordHeader*>(bytes + offset);
        offset += 6;

        switch (header.id) {
        case 22151:
          return 0;

        case 22152: {
          UIItemRepairEntry entry;
          std::memcpy(&entry, bytes + offset, header.bytes);
          offset += header.bytes;
          this->SendMsg(nullptr, UM_ADDITEM, reinterpret_cast<std::intptr_t>(&entry), 0, 0, 0);
          break;
        }

        default:
          offset += header.bytes;
          break;
        }
      }
    }

    return 0;
  }
  }

  return this->UIFrameWnd::SendMsg(sender, message, a, b, c, d);
}

// OFFSET: 0x009A4C50
// FUNCTION: fn_13618
int UIMakeTargetResultWnd::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::intptr_t b, std::intptr_t c, std::intptr_t d) {
  switch (message) {
  case UM_COMMAND:
    g_windowMgr.CloseWindow(WID_MAKETARGETRESULTWND);
    return 0;

  case UM_SETCURITEM:
    this->makeType = static_cast<int>(a);
    if (b) {
      this->succeeded = true;
    }

    this->Invalidate();
    return 0;
  }

  return this->UIFrameWnd::SendMsg(sender, message, a, b, c, d);
}

// OFFSET: 0x0099F780
// FUNCTION: fn_13587
UIItemRepairWnd::UIItemRepairWnd()
    : UIFrameWnd(0), itemIds(), indices(), entries() {
}

// OFFSET: 0x0099F850
// FUNCTION: fn_13588
UIMakeTargetListWnd::UIMakeTargetListWnd()
    : UIFrameWnd(0), itemIds() {
}

// OFFSET: 0x0099F8D0
// FUNCTION: fn_13589
UIMakeTargetProcessWnd::UIMakeTargetProcessWnd()
    : UIFrameWnd(0), materials() {
}

// OFFSET: 0x0099F950
// FUNCTION: fn_13590
UIMakeTargetResultWnd::UIMakeTargetResultWnd()
    : UIFrameWnd(0) {
  this->succeeded = false;
  this->makeType = 0;
}

// OFFSET: 0x0099F9C0
// FUNCTION: fn_13591
UIWeaponRefineWnd::UIWeaponRefineWnd()
    : UIFrameWnd(0), itemIds(), indices() {
}

// OFFSET: 0x0099FB70
// FUNCTION: fn_13592
UIItemRepairWnd::~UIItemRepairWnd() = default;

// OFFSET: 0x009A0280
// FUNCTION: fn_13599
std::vector<unsigned char> UIItemRepairWnd::GetReplayData() {
  std::vector<unsigned char> records;
  {
    const auto record = BuildReplayTaggedRecord(22150, nullptr, 0);
    records.insert(records.end(), record.begin(), record.end());
  }
  for (auto it = this->entries.begin(); it != this->entries.end(); ++it) {
    const UIItemRepairEntry& entry = *it;
    std::vector<unsigned char> record(sizeof(entry) + 6, 0);
    *reinterpret_cast<std::uint16_t*>(record.data()) = 22152;
    *reinterpret_cast<std::uint32_t*>(record.data() + 2) = sizeof(entry);
    std::memcpy(record.data() + 6, &entry, sizeof(entry));
    records.insert(records.end(), record.cbegin(), record.cend());
  }
  {
    const auto record = BuildReplayTaggedRecord(22151, nullptr, 0);
    records.insert(records.end(), record.begin(), record.end());
  }
  return records;
}