class

Vendor

16 properties
61 functions

Properties

Property	Type	Offset
`gameInstance`	`ScriptGameInstance`	`0x0`	scripted
`vendorObject`	`WeakHandle<game.Object>`	`0x18`	scripted
`tweakID`	`TDBID`	`0x28`	scripted
`lastInteractionTime`	`float`	`0x30`	scripted
`stock`	`game.SItemStack[]`	`0x38`	scripted
`newItems`	`TDBID[]`	`0x48`	scripted
`soldItems`	`SoldItemsCache?`	`0x58`	scripted
`priceMultiplier`	`float`	`0x68`	scripted
`vendorPersistentID`	`game.PersistentID`	`0x70`	scripted
`stockInit`	`bool`	`0x80`	scripted
`playerHacksInit`	`bool`	`0x81`	scripted
`inventoryInit`	`bool`	`0x82`	scripted
`isAttached`	`bool`	`0x83`	scripted
`inventoryReinitWithPlayerStats`	`bool`	`0x84`	scripted
`vendorRecord`	`WeakHandle<game.data.Vendor_Record>`	`0x88`	scripted
`playerHacks`	`game.ItemID[]`	`0x98`	scripted

Functions

void Initialize(ScriptGameInstance gameInstance, TDBID vendorID, game.Object vendorObject) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "Initialize;GameInstanceTweakDBIDGameObject",
    (Vendor_Initialize x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_Initialize(
    Vendor self,
    ScriptGameInstance gameInstance,
    TDBID vendorID,
    game.Object? vendorObject
);

void OnAttach(WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "OnAttach;GameObject",
    (Vendor_OnAttach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_OnAttach(
    Vendor self,
    WeakHandle<game.Object> owner
);

void OnDeattach(WeakHandle<game.Object> owner) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "OnDeattach;GameObject",
    (Vendor_OnDeattach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_OnDeattach(
    Vendor self,
    WeakHandle<game.Object> owner
);

void OnRestored(ScriptGameInstance gameInstance, bool forceReinit) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "OnRestored;GameInstanceBool",
    (Vendor_OnRestored x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_OnRestored(
    Vendor self,
    ScriptGameInstance gameInstance,
    bool forceReinit
);

bool IsAttached() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "IsAttached;",
    (Vendor_IsAttached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_IsAttached(
    Vendor self
);

game.SItemStack[] GetStock() RTTI

void LazyInitStock() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "LazyInitStock;",
    (Vendor_LazyInitStock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_LazyInitStock(
    Vendor self
);

void InitPlayerHacks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "InitPlayerHacks;",
    (Vendor_InitPlayerHacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_InitPlayerHacks(
    Vendor self
);

game.PersistentID GetVendorPersistentID() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetVendorPersistentID;",
    (Vendor_GetVendorPersistentID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PersistentID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetVendorPersistentID(
    Vendor self
);

TDBID GetVendorTweakID() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetVendorTweakID;",
    (Vendor_GetVendorTweakID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetVendorTweakID(
    Vendor self
);

game.data.VendorType GetVendorType() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetVendorType;",
    (Vendor_GetVendorType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.VendorType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetVendorType(
    Vendor self
);

game.data.Vendor_Record? GetVendorRecord() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetVendorRecord;",
    (Vendor_GetVendorRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Vendor_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetVendorRecord(
    Vendor self
);

WeakHandle<game.Object> GetVendorObject() RTTI

float GetPriceMultiplier() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetPriceMultiplier;",
    (Vendor_GetPriceMultiplier x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetPriceMultiplier(
    Vendor self
);

float GetLastInteractionTime() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetLastInteractionTime;",
    (Vendor_GetLastInteractionTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetLastInteractionTime(
    Vendor self
);

SoldItemsCache? GetSoldItems() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetSoldItems;",
    (Vendor_GetSoldItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SoldItemsCache>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetSoldItems(
    Vendor self
);

game.SItemStack[] GetItemsForSale(bool checkPlayerCanBuy) RTTI

int GetMoney() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetMoney;",
    (Vendor_GetMoney x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetMoney(
    Vendor self
);

game.SItemStack[] GetCyberwareForSale(bool checkPlayerCanBuy) RTTI
game.SItemStack[] GetAllStockForSale(bool checkPlayerCanBuy) RTTI
game.SItemStack[] GetItemsPlayerCanSell(bool allowQuestItems, bool excludeEquipped) RTTI

void OnVendorMenuOpen() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "OnVendorMenuOpen;",
    (Vendor_OnVendorMenuOpen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_OnVendorMenuOpen(
    Vendor self
);

void SetPriceMultiplier(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "SetPriceMultiplier;Float",
    (Vendor_SetPriceMultiplier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_SetPriceMultiplier(
    Vendor self,
    float value
);

void SetPersistentID(game.PersistentID persistentID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "SetPersistentID;PersistentID",
    (Vendor_SetPersistentID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_SetPersistentID(
    Vendor self,
    game.PersistentID persistentID
);

bool PlayerCanSell(game.ItemID itemID, bool allowQuestItems, bool excludeEquipped) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "PlayerCanSell;ItemIDBoolBool",
    (Vendor_PlayerCanSell x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_PlayerCanSell(
    Vendor self,
    game.ItemID itemID,
    bool allowQuestItems,
    bool excludeEquipped
);

bool PlayerCanBuy(game.SItemStack itemStack) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "PlayerCanBuy;script_ref<SItemStack>",
    (Vendor_PlayerCanBuy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_PlayerCanBuy(
    Vendor self,
    game.SItemStack itemStack
);

bool CompareWithPlayerGrenadesQuality(game.SItemStack itemStack) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "CompareWithPlayerGrenadesQuality;script_ref<SItemStack>",
    (Vendor_CompareWithPlayerGrenadesQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_CompareWithPlayerGrenadesQuality(
    Vendor self,
    game.SItemStack itemStack
);

bool CompareWithPlayerHealingItemsQuality(game.SItemStack itemStack) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "CompareWithPlayerHealingItemsQuality;script_ref<SItemStack>",
    (Vendor_CompareWithPlayerHealingItemsQuality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_CompareWithPlayerHealingItemsQuality(
    Vendor self,
    game.SItemStack itemStack
);

void FillVendorInventory(bool allowRegeneration) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "FillVendorInventory;Bool",
    (Vendor_FillVendorInventory x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_FillVendorInventory(
    Vendor self,
    bool allowRegeneration
);

void InitializeStock() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "InitializeStock;",
    (Vendor_InitializeStock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_InitializeStock(
    Vendor self
);

void LoadPlayerHacks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "LoadPlayerHacks;",
    (Vendor_LoadPlayerHacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_LoadPlayerHacks(
    Vendor self
);

void RegenerateStock() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "RegenerateStock;",
    (Vendor_RegenerateStock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_RegenerateStock(
    Vendor self
);

void UpdateNewItems(game.SItemStack[] newStock) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "UpdateNewItems;script_ref<array<SItemStack>>",
    (Vendor_UpdateNewItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_UpdateNewItems(
    Vendor self,
    game.SItemStack[] newStock
);

int CalculateQuantityForStack(game.data.VendorWare_Record vendorWare, PlayerPuppet player) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "CalculateQuantityForStack;VendorWare_RecordPlayerPuppet",
    (Vendor_CalculateQuantityForStack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_CalculateQuantityForStack(
    Vendor self,
    game.data.VendorWare_Record? vendorWare,
    PlayerPuppet? player
);

void InitSingleItemStack(out game.SItemStack itemStack, game.data.Item_Record itemRecord, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "InitSingleItemStack;SItemStackItem_RecordItemID",
    (Vendor_InitSingleItemStack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_InitSingleItemStack(
    Vendor self,
    game.SItemStack itemStack,
    game.data.Item_Record? itemRecord,
    game.ItemID itemID
);

void CreateStacksFromVendorItemQuery(out game.SItemStack[] outputStack, WeakHandle<game.data.VendorItemQuery_Record> vendorItemQuery, PlayerPuppet player)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "CreateStacksFromVendorItemQuery;array<SItemStack>VendorItemQuery_RecordPlayerPuppet",
    (Vendor_CreateStacksFromVendorItemQuery x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_CreateStacksFromVendorItemQuery(
    Vendor self,
    game.SItemStack[] outputStack,
    WeakHandle<game.data.VendorItemQuery_Record> vendorItemQuery,
    PlayerPuppet? player
);

void CreateStacksFromVendorItem(out game.SItemStack[] outputStacks, WeakHandle<game.data.VendorItem_Record> vendorItem, PlayerPuppet player)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "CreateStacksFromVendorItem;array<SItemStack>VendorItem_RecordPlayerPuppet",
    (Vendor_CreateStacksFromVendorItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_CreateStacksFromVendorItem(
    Vendor self,
    game.SItemStack[] outputStacks,
    WeakHandle<game.data.VendorItem_Record> vendorItem,
    PlayerPuppet? player
);

void CreateDynamicStockFromPlayerProgression(out game.SItemStack[] outputStacks, WeakHandle<game.Object> player) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "CreateDynamicStockFromPlayerProgression;array<SItemStack>GameObject",
    (Vendor_CreateDynamicStockFromPlayerProgression x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_CreateDynamicStockFromPlayerProgression(
    Vendor self,
    game.SItemStack[] outputStacks,
    WeakHandle<game.Object> player
);

bool ShouldRegenerateStock() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "ShouldRegenerateStock;",
    (Vendor_ShouldRegenerateStock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_ShouldRegenerateStock(
    Vendor self
);

bool ShouldRegenerateItem(TDBID itemTDBID) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "ShouldRegenerateItem;TweakDBID",
    (Vendor_ShouldRegenerateItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_ShouldRegenerateItem(
    Vendor self,
    TDBID itemTDBID
);

bool AlwaysInStock(TDBID itemTDBID) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "AlwaysInStock;TweakDBID",
    (Vendor_AlwaysInStock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_AlwaysInStock(
    Vendor self,
    TDBID itemTDBID
);

void SellItemToVendor(game.SItemStack itemStack, int requestId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "SellItemToVendor;script_ref<SItemStack>Int32",
    (Vendor_SellItemToVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_SellItemToVendor(
    Vendor self,
    game.SItemStack itemStack,
    int requestId
);

void SellItemsToVendor(game.SItemStack[] itemsStack, int requestId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "SellItemsToVendor;script_ref<array<SItemStack>>Int32",
    (Vendor_SellItemsToVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_SellItemsToVendor(
    Vendor self,
    game.SItemStack[] itemsStack,
    int requestId
);

void BuyItemFromVendor(game.SItemStack itemStack, int requestId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "BuyItemFromVendor;script_ref<SItemStack>Int32",
    (Vendor_BuyItemFromVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_BuyItemFromVendor(
    Vendor self,
    game.SItemStack itemStack,
    int requestId
);

void BuyItemsFromVendor(game.SItemStack[] itemsStack, int requestId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "BuyItemsFromVendor;script_ref<array<SItemStack>>Int32",
    (Vendor_BuyItemsFromVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_BuyItemsFromVendor(
    Vendor self,
    game.SItemStack[] itemsStack,
    int requestId
);

void BuybackItemFromVendor(game.SItemStack itemStack, int requestId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "BuybackItemFromVendor;script_ref<SItemStack>Int32",
    (Vendor_BuybackItemFromVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_BuybackItemFromVendor(
    Vendor self,
    game.SItemStack itemStack,
    int requestId
);

void BuybackItemsFromVendor(game.SItemStack[] itemsStack, int requestId) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "BuybackItemsFromVendor;script_ref<array<SItemStack>>Int32",
    (Vendor_BuybackItemsFromVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_BuybackItemsFromVendor(
    Vendor self,
    game.SItemStack[] itemsStack,
    int requestId
);

void DispenseItemFromVendor(Vector4 position, game.ItemID? itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "DispenseItemFromVendor;Vector4ItemID",
    (Vendor_DispenseItemFromVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_DispenseItemFromVendor(
    Vendor self,
    Vector4 position,
    game.ItemID? itemID
);

void DispenseItemStackFromVendor(Vector4 position, game.ItemID itemID, int amount, bool? bypassStock) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "DispenseItemStackFromVendor;Vector4ItemIDInt32Bool",
    (Vendor_DispenseItemStackFromVendor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_DispenseItemStackFromVendor(
    Vendor self,
    Vector4 position,
    game.ItemID itemID,
    int amount,
    bool? bypassStock
);

game.ItemID GetRandomStockItem() RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetRandomStockItem;",
    (Vendor_GetRandomStockItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetRandomStockItem(
    Vendor self
);

bool PerformItemTransfer(WeakHandle<game.Object> buyer, WeakHandle<game.Object> seller, SItemTransaction itemTransaction)

RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "PerformItemTransfer;GameObjectGameObjectscript_ref<SItemTransaction>",
    (Vendor_PerformItemTransfer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_PerformItemTransfer(
    Vendor self,
    WeakHandle<game.Object> buyer,
    WeakHandle<game.Object> seller,
    SItemTransaction itemTransaction
);

void AddItemsToStock(game.SItemStack itemStack) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "AddItemsToStock;script_ref<SItemStack>",
    (Vendor_AddItemsToStock x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_AddItemsToStock(
    Vendor self,
    game.SItemStack itemStack
);

bool RemoveItemsFromStock(game.SItemStack itemStack) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "RemoveItemsFromStock;script_ref<SItemStack>",
    (Vendor_RemoveItemsFromStock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_RemoveItemsFromStock(
    Vendor self,
    game.SItemStack itemStack
);

int GetItemIndex(game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "GetItemIndex;ItemID",
    (Vendor_GetItemIndex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetItemIndex(
    Vendor self,
    game.ItemID itemID
);

bool RemoveItemIDFromStock(game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "RemoveItemIDFromStock;ItemID",
    (Vendor_RemoveItemIDFromStock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_RemoveItemIDFromStock(
    Vendor self,
    game.ItemID itemID
);

void ItemInspected(TDBID itemTDBID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Vendor",
    "ItemInspected;TweakDBID",
    (Vendor_ItemInspected x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_ItemInspected(
    Vendor self,
    TDBID itemTDBID
);

bool IsNewItem(TDBID itemTDBID) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "IsNewItem;TweakDBID",
    (Vendor_IsNewItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_IsNewItem(
    Vendor self,
    TDBID itemTDBID
);

TDBID[] GetNewItems() RTTI

bool DoesEquipAreaContainNewItems(game.data.EquipmentArea area, bool checkPlayerCanBuy) RTTI

Generated hook

re.Hooks.Place(
    "Vendor",
    "DoesEquipAreaContainNewItems;gamedataEquipmentAreaBool",
    (Vendor_DoesEquipAreaContainNewItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_DoesEquipAreaContainNewItems(
    Vendor self,
    game.data.EquipmentArea area,
    bool checkPlayerCanBuy
);

static int GetMaxItemStacksPerVendor(bool useIncreasedLimit) staticRTTI global

Generated hook

re.Hooks.Place(
    "Vendor",
    "Vendor::GetMaxItemStacksPerVendor;Bool",
    (Vendor_GetMaxItemStacksPerVendor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_GetMaxItemStacksPerVendor(
    bool useIncreasedLimit
);

static bool ShouldDiscardQualityForNewCWs() staticRTTI global

Generated hook

re.Hooks.Place(
    "Vendor",
    "Vendor::ShouldDiscardQualityForNewCWs;",
    (Vendor_ShouldDiscardQualityForNewCWs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Vendor_ShouldDiscardQualityForNewCWs();