class

MarketSystem

2 properties
34 functions

Extends game.IMarketSystem game.ScriptableSystem game.IScriptableSystem IScriptable ISerializable

Properties

Property	Type	Offset
`vendors`	`Vendor?[]`	`0x0`	scripted
`vendingMachinesVendors`	`Vendor?[]`	`0x10`	scripted

Functions

void OnDetach() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnDetach;",
    (MarketSystem_OnDetach x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnDetach(
    MarketSystem self
);

void OnRestored(int saveVersion, int gameVersion) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnRestored;Int32Int32",
    (MarketSystem_OnRestored x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnRestored(
    MarketSystem self,
    int saveVersion,
    int gameVersion
);

Vendor? GetVendor(game.Object vendorObject) RTTI

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "GetVendor;GameObject",
    (MarketSystem_GetVendor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vendor>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetVendor(
    MarketSystem self,
    game.Object? vendorObject
);

Vendor? GetOrAddVendor(game.Object vendorObject) RTTI

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "GetOrAddVendor;GameObject",
    (MarketSystem_GetOrAddVendor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vendor>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetOrAddVendor(
    MarketSystem self,
    game.Object? vendorObject
);

Vendor? GetVendorByTDBID(TDBID vendorDataID) RTTI

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "GetVendorByTDBID;TweakDBID",
    (MarketSystem_GetVendorByTDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vendor>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetVendorByTDBID(
    MarketSystem self,
    TDBID vendorDataID
);

Vendor? AddVendor(game.Object vendorObject) RTTI

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "AddVendor;GameObject",
    (MarketSystem_AddVendor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vendor>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_AddVendor(
    MarketSystem self,
    game.Object? vendorObject
);

void OnAttachVendorRequest(AttachVendorRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnAttachVendorRequest;AttachVendorRequest",
    (MarketSystem_OnAttachVendorRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnAttachVendorRequest(
    MarketSystem self,
    AttachVendorRequest? request
);

void OnDeattachVendorRequest(DeattachVendorRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnDeattachVendorRequest;DeattachVendorRequest",
    (MarketSystem_OnDeattachVendorRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnDeattachVendorRequest(
    MarketSystem self,
    DeattachVendorRequest? request
);

void OnBuyRequest(BuyRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnBuyRequest;BuyRequest",
    (MarketSystem_OnBuyRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnBuyRequest(
    MarketSystem self,
    BuyRequest? request
);

void OnBuybackRequest(BuybackRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnBuybackRequest;BuybackRequest",
    (MarketSystem_OnBuybackRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnBuybackRequest(
    MarketSystem self,
    BuybackRequest? request
);

void OnSellRequest(SellRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnSellRequest;SellRequest",
    (MarketSystem_OnSellRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnSellRequest(
    MarketSystem self,
    SellRequest? request
);

void OnDispenseRequest(DispenseRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnDispenseRequest;DispenseRequest",
    (MarketSystem_OnDispenseRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnDispenseRequest(
    MarketSystem self,
    DispenseRequest? request
);

void OnDispenseStackRequest(DispenseStackRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnDispenseStackRequest;DispenseStackRequest",
    (MarketSystem_OnDispenseStackRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnDispenseStackRequest(
    MarketSystem self,
    DispenseStackRequest? request
);

void OnAddItemToStockRequest(AddItemToVendorRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnAddItemToStockRequest;AddItemToVendorRequest",
    (MarketSystem_OnAddItemToStockRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnAddItemToStockRequest(
    MarketSystem self,
    AddItemToVendorRequest? request
);

void OnSetPriceModifierRequest(SetVendorPriceMultiplierRequest request) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "OnSetPriceModifierRequest;SetVendorPriceMultiplierRequest",
    (MarketSystem_OnSetPriceModifierRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnSetPriceModifierRequest(
    MarketSystem self,
    SetVendorPriceMultiplierRequest? request
);

static bool IsNewItem(WeakHandle<game.Object> vendorObject, TDBID itemTDBID) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::IsNewItem;GameObjectTweakDBID",
    (MarketSystem_IsNewItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_IsNewItem(
    WeakHandle<game.Object> vendorObject,
    TDBID itemTDBID
);

static bool IsAttached(WeakHandle<game.Object> vendorObject) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::IsAttached;GameObject",
    (MarketSystem_IsAttached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_IsAttached(
    WeakHandle<game.Object> vendorObject
);

static SoldItemsCache? GetVendorSoldItems(WeakHandle<game.Object> vendorObject) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::GetVendorSoldItems;GameObject",
    (MarketSystem_GetVendorSoldItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SoldItemsCache>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetVendorSoldItems(
    WeakHandle<game.Object> vendorObject
);

static game.ItemID Money() staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::Money;",
    (MarketSystem_Money x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

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

static game.SItemStack[] GetVendorCyberwareForSale(WeakHandle<game.Object> vendorObject, bool checkPlayerCanBuy) staticRTTI global

static bool CanPlayerSellItem(WeakHandle<game.Object> vendorObject, game.ItemID itemID, bool allowQuestItems, bool excludeEquipped)

staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::CanPlayerSellItem;GameObjectItemIDBoolBool",
    (MarketSystem_CanPlayerSellItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_CanPlayerSellItem(
    WeakHandle<game.Object> vendorObject,
    game.ItemID itemID,
    bool allowQuestItems,
    bool excludeEquipped
);

static int GetBuyPrice(WeakHandle<game.Object> vendorObject, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::GetBuyPrice;GameObjectItemID",
    (MarketSystem_GetBuyPrice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetBuyPrice(
    WeakHandle<game.Object> vendorObject,
    game.ItemID itemID
);

static TDBID GetVendorID(WeakHandle<game.Object> vendor) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::GetVendorID;GameObject",
    (MarketSystem_GetVendorID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetVendorID(
    WeakHandle<game.Object> vendor
);

static int GetBuyPrice(ScriptGameInstance game, ent.EntityID vendorID, game.ItemID itemID) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::GetBuyPrice;GameInstanceEntityIDItemID",
    (MarketSystem_GetBuyPrice2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetBuyPrice2(
    ScriptGameInstance game,
    ent.EntityID vendorID,
    game.ItemID itemID
);

static bool IsAccessible(WeakHandle<PlayerPuppet> player, TDBID vendorID) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::IsAccessible;PlayerPuppetTweakDBID",
    (MarketSystem_IsAccessible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_IsAccessible(
    WeakHandle<PlayerPuppet> player,
    TDBID vendorID
);

static MarketSystem? GetInstance(ScriptGameInstance gameInstance) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::GetInstance;GameInstance",
    (MarketSystem_GetInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.MarketSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetInstance(
    ScriptGameInstance gameInstance
);

static bool IsVisibleOnMap(WeakHandle<PlayerPuppet> player, TDBID vendorID) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::IsVisibleOnMap;PlayerPuppetTweakDBID",
    (MarketSystem_IsVisibleOnMap x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_IsVisibleOnMap(
    WeakHandle<PlayerPuppet> player,
    TDBID vendorID
);

static void ItemInspected(WeakHandle<game.Object> vendorObject, TDBID itemTDBID) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "MarketSystem::ItemInspected;GameObjectTweakDBID",
    (MarketSystem_ItemInspected x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_ItemInspected(
    WeakHandle<game.Object> vendorObject,
    TDBID itemTDBID
);

static TDBID[] GetNewItems(WeakHandle<game.Object> vendorObject) staticRTTI global
static game.SItemStack[] GetVendorItemsForSale(WeakHandle<game.Object> vendorObject, bool checkPlayerCanBuy) staticRTTI global

static bool DoesEquipAreaContainNewItems(WeakHandle<game.Object> vendorObject, game.data.EquipmentArea area, bool checkPlayerCanBuy)

staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::DoesEquipAreaContainNewItems;GameObjectgamedataEquipmentAreaBool",
    (MarketSystem_DoesEquipAreaContainNewItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_DoesEquipAreaContainNewItems(
    WeakHandle<game.Object> vendorObject,
    game.data.EquipmentArea area,
    bool checkPlayerCanBuy
);

static int GetVendorMoney(WeakHandle<game.Object> vendorObject) staticRTTI global

Generated hook

re.Hooks.Place(
    "MarketSystem",
    "MarketSystem::GetVendorMoney;GameObject",
    (MarketSystem_GetVendorMoney x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_GetVendorMoney(
    WeakHandle<game.Object> vendorObject
);

static void OnVendorMenuOpen(game.Object vendorObject) staticRTTI global

Generated hook

re.Hooks.PlaceVoid(
    "MarketSystem",
    "MarketSystem::OnVendorMenuOpen;GameObject",
    (MarketSystem_OnVendorMenuOpen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct MarketSystem_OnVendorMenuOpen(
    game.Object? vendorObject
);

static game.SItemStack[] GetItemsPlayerCanSell(WeakHandle<game.Object> vendorObject, bool allowQuestItems, bool excludeEquipped) staticRTTI global