rodecomp/Source/UI/Items/UIMakeTargetProcessWnd.cpp

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

#include "Client/Mode/ModeDragState.h"
#include "Client/Mode/ModeMgr.h"
#include "Client/Replay/Replay.h"
#include "Client/Session/Session.h"
#include "Contents/Items/ItemDescription.h"
#include "Contents/Items/ItemId.h"
#include "Contents/Tables/MessageTable.h"
#include "Resource/Bitmap/BitmapResource.h"
#include "Resource/ResourceMgr.h"
#include "Resource/Bitmap/TextureNames.h"
#include "UI/Buttons/UIButton.h"
#include "UI/Shop/ItemDrawing.h"
#include "UI/Window/UIWindowMgr.h"
#include "UI/Window/WindowManagerWindows.h"

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


// OFFSET: 0x009A0090
// FUNCTION: fn_13598
void UIMakeTargetProcessWnd::DragAndDrop(int x, int y, std::intptr_t value) {
  switch (this->makeType) {
  case ITEMID_FLAME_HEART:
  case ITEMID_MISTIC_FROZEN:
  case ITEMID_ROUGH_WIND:
  case ITEMID_GREAT_NATURE:
  case ITEMID_IRON:
  case ITEMID_STEEL:
  case ITEMID_STAR_CRUMB:
    g_modeMgr.GetGameMode()->SendMsg(MM_CANCEL_DRAG, 0, 0, 0, 0);
    return;
  }

  const ModeDragState* drag = reinterpret_cast<const ModeDragState*>(value);
  if (drag->source == 1) {
    bool hasElementalStone = false;
    int emptySlot = 3;
    for (int index = 0; index < 3; ++index) {
      if (this->materials[index].identity[1] > 0) {
        hasElementalStone |= this->materials[index].IsElementalStone();
      } else if (emptySlot == 3) {
        emptySlot = index;
      }
    }

    if (emptySlot < 3) {
      ITEM_INFO item = LookupClientItemByIdentity(g_session.m_inventoryItems, drag->id);
      if (item.identity[1] > 0 && item.IsForgeMaterial() && (!hasElementalStone || !item.IsElementalStone())) {
        this->materials[emptySlot] = item;
        this->materials[emptySlot].quantity = 1;
        g_session.RemoveInventoryItem(item.identity[1], 1);
        if (g_windowMgr.itemWnd) {
          reinterpret_cast<UIWindow*>(g_windowMgr.itemWnd)->SendMsg(nullptr, UM_REFRESHITEM, 0, 0, 0, 0);
        }
        this->Invalidate();
      }
    }
  }

  g_modeMgr.gameMode->SendMsg(MM_CANCEL_DRAG, 0, 0, 0, 0);
}

// OFFSET: 0x009A0690
// FUNCTION: fn_13601
std::vector<unsigned char> UIMakeTargetProcessWnd::GetReplayData() {
  std::vector<unsigned char> records;
  {
    const auto record = BuildReplayTaggedRecord(22000, nullptr, 0);
    records.insert(records.end(), record.begin(), record.end());
  }
  {
    const auto record = BuildReplayTaggedRecord(22002, &this->makeType, sizeof(this->makeType));
    records.insert(records.end(), record.begin(), record.end());
  }
  {
    const auto record = BuildReplayTaggedRecord(22001, nullptr, 0);
    records.insert(records.end(), record.begin(), record.end());
  }
  return records;
}

// OFFSET: 0x009A09E0
// FUNCTION: fn_13603
ITEM_INFO UIMakeTargetProcessWnd::GetItemAt(int x, int y) {
  switch (this->makeType) {
  case ITEMID_FLAME_HEART:
  case ITEMID_MISTIC_FROZEN:
  case ITEMID_ROUGH_WIND:
  case ITEMID_GREAT_NATURE:
  case ITEMID_IRON:
  case ITEMID_STEEL:
  case ITEMID_STAR_CRUMB:
    return ITEM_INFO(0);
  }

  if (y > this->geometry.height - 56 && y < this->geometry.height - 32) {
    if (x >= 4 && x <= 34) {
      return this->materials[0];
    }
    if (x >= 36 && x <= 66) {
      return this->materials[1];
    }
    if (x >= 68 && x <= 98) {
      return this->materials[2];
    }
  }

  return ITEM_INFO(0);
}

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

  switch (this->makeType) {
  case ITEMID_FLAME_HEART:
  case ITEMID_MISTIC_FROZEN:
  case ITEMID_ROUGH_WIND:
  case ITEMID_GREAT_NATURE:
  case ITEMID_IRON:
  case ITEMID_STEEL:
  case ITEMID_STAR_CRUMB:
    break;
  default: {
    const ITEM_INFO* material = this->materials;
    for (int x = 8; x < 104; x += 32, ++material) {
      auto* bar = static_cast<CBitmapRes*>(ResourceMgr::Instance().Load(Resolve("유저인터페이스\\basic_interface\\btnbar_right2.bmp")));
      DrawItemSlotBackground(*this, x - 4, this->geometry.height - bar->image.height - 32);
      if (material->identity[1] > 0) {
        DrawItemIcon(*this, ResourceMgr::Instance(), x, this->geometry.height - bar->image.height - 28, *material, 0);
      }
    }
    break;
  }
  }

  ITEM_INFO item;
  item.SetItemId(this->makeType);
  item.refiningLevel = 0;
  item.identified = 1;
  const int nameWidth = this->DrawFittedItemName(16, 2, &item, 0, 0, 12, 0);
  this->DrawShadowedText(nameWidth + 16, 2, LookupMessage(MSI_MAKE_TARGET), 0, 0, 0xFFFFFF, 0, 12, 0);
  const int requiredWidth = this->DrawFittedItemName(16, 22, &item, 0, 0, 12, 0);
  this->DrawShadowedText(requiredWidth + 16, 22, LookupMessage(MSI_REQUIRE_FOR_MAKE_TARGET), 0, 0, 0xFFFFFF, 0, 12, 0);

  const std::vector<const char*>& lines = FindMetalProcessItems(this->makeType);
  int y = 42;
  for (unsigned int index = 0; index < lines.size(); ++index, y += 20) {
    this->DrawTextAt(16, y, lines[index], 0, 0, 12, 0, 0, 0);
  }
}

// OFFSET: 0x009A3D10
// FUNCTION: fn_13614
void UIMakeTargetProcessWnd::OnLBtnDown(int x, int y) {
  ITEM_INFO item = this->GetItemAt(x, y);
  if (item.identity[1] > 0) {
    g_modeMgr.gameMode->SendMsg(MM_BEGIN_DRAG_FROM_METALPROCESSWND, reinterpret_cast<int>(item.itemId.c_str()), 0, 0, 0);
  } else {
    this->UIFrameWnd::OnLBtnDown(x, y);
  }
}

// OFFSET: 0x009A48C0
// FUNCTION: fn_13617
int UIMakeTargetProcessWnd::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_SETCURITEM:
    this->makeType = static_cast<int>(a);
    this->Invalidate();
    return 0;

  case UM_CLEAR_ITEM: {
    const char* name = reinterpret_cast<const char*>(a);
    for (int index = 2; index >= 0; --index) {
      ITEM_INFO& material = this->materials[index];
      if (material.identity[1] > 0 && material.itemId == name) {
        g_session.AddInventoryItem(material, 1);
        material.Reset();
        this->Invalidate();
        return 0;
      }
    }

    return 0;
  }

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

    switch (response) {
    case ID_OK:
      g_modeMgr.GetGameMode()->SendMsg(MM_REQ_MAKING_ITEM, this->makeType, reinterpret_cast<int>(this->materials), 0, 0);
      g_windowMgr.CloseWindow(WID_MAKETARGETPROCESSWND);
      return 0;

    case ID_CANCEL: {
      g_modeMgr.GetGameMode()->SendMsg(MM_REQ_MAKING_ITEM, 0, reinterpret_cast<int>(this->materials), 0, 0);
      bool restored = false;
      for (int index = 0; index < 3; ++index) {
        if (this->materials[index].identity[1] > 0) {
          restored = true;
          g_session.AddInventoryItem(this->materials[index], 0);
        }
      }

      if (restored) {
        RefreshItemWindows(&g_windowMgr);
      }

      if (g_windowMgr.itemWnd) {
        reinterpret_cast<UIWindow*>(g_windowMgr.itemWnd)->SendMsg(nullptr, UM_REFRESHITEM, 0, 0, 0, 0);
      }

      g_windowMgr.CloseWindow(WID_MAKETARGETPROCESSWND);
      return 0;
    }
    }

    return 0;
  }

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

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

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

    const auto* bytes = reinterpret_cast<const unsigned char*>(a);
    ReplayTag tag;
    std::memcpy(&tag, bytes, sizeof(tag));
    unsigned offset = sizeof(tag);

    if (tag.id == 22000) {
      while (static_cast<unsigned>(b) > offset) {
        std::memcpy(&tag, bytes + offset, sizeof(tag));
        offset += sizeof(tag);

        if (tag.id == 22001) {
          break;
        }

        if (tag.id == 22002) {
          std::memcpy(&this->makeType, bytes + offset, tag.bytes);
          offset += tag.bytes;
          this->SendMsg(nullptr, UM_SETCURITEM, this->makeType, 0, 0, 0);
        } else {
          offset += tag.bytes;
        }
      }
    }

    return 0;
  }
  }

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