feat: trade resources (#543)

* impl Mul<MarketFee> for Gold

* set_fee

* set_fee

* store

* cheat set vault

* sell_resources

* withdraw_resources_up_to

* withdraw_resources

* sell

* test

* destructure

* sum

* buy

* test

* endpoints

* dprint

* request

* deps

* MarketImpl

* MarketPrice

* scene

* fix buy

* market

Author: ferreira-tb

.npmrc

@@ -0,0 +1 @@
+ignore-scripts=true

Cargo.lock

@@ -13,3 +13,17 @@ pub async fn cheat_set_market_fee(app: AppHandle, req: CheatSetMarketFeeRequest)
     .await
     .map_err(Into::into)
 }
+
+#[tauri::command]
+pub async fn cheat_set_market_vault_resources(
+  app: AppHandle,
+  req: CheatSetMarketVaultResourcesRequest,
+) -> Result<()> {
+  app
+    .client(async |cl| {
+      cl.cheat_set_market_vault_resources(req)
+        .await
+    })
+    .await
+    .map_err(Into::into)
+}

app/src-tauri/src/command/cheat/market.rs

@@ -7,6 +7,14 @@ use nil_payload::request::market::*;
 use nil_payload::response::market::*;
 use tauri::AppHandle;
 
+#[tauri::command]
+pub async fn buy_resources(app: AppHandle, req: BuyResourcesRequest) -> Result<()> {
+  app
+    .client(async |cl| cl.buy_resources(req).await)
+    .await
+    .map_err(Into::into)
+}
+
 #[tauri::command]
 pub async fn get_market(app: AppHandle, req: GetMarketRequest) -> Result<GetMarketResponse> {
   app
@@ -26,6 +34,14 @@ pub async fn get_market_fee(
     .map_err(Into::into)
 }
 
+#[tauri::command]
+pub async fn sell_resources(app: AppHandle, req: SellResourcesRequest) -> Result<()> {
+  app
+    .client(async |cl| cl.sell_resources(req).await)
+    .await
+    .map_err(Into::into)
+}
+
 #[tauri::command]
 pub async fn send_resources(app: AppHandle, req: SendResourcesRequest) -> Result<()> {
   app

app/src-tauri/src/command/market.rs

@@ -72,6 +72,7 @@ pub fn run() {
       command::cheat::infrastructure::cheat_set_building_level,
       command::cheat::infrastructure::cheat_set_max_infrastructure,
       command::cheat::market::cheat_set_market_fee,
+      command::cheat::market::cheat_set_market_vault_resources,
       command::cheat::military::cheat_get_idle_armies_at,
       command::cheat::military::cheat_get_idle_personnel_at,
       command::cheat::military::cheat_get_maneuvers,
@@ -125,8 +126,10 @@ pub fn run() {
       command::infrastructure::workshop::add_workshop_recruit_order,
       command::infrastructure::workshop::cancel_workshop_recruit_order,
       command::infrastructure::workshop::get_workshop_recruit_catalog,
+      command::market::buy_resources,
       command::market::get_market,
       command::market::get_market_fee,
+      command::market::sell_resources,
       command::market::send_resources,
       command::military::cancel_maneuver,
       command::military::get_armies,

app/src-tauri/src/lib.rs

@@ -4,6 +4,7 @@
 export * from "./npc";
 export * from "./city";
 export * from "./round";
+export * from "./market";
 export * from "./player";
 export * from "./behavior";
 export * from "./military";

app/src/commands/cheat/index.ts

@@ -2,7 +2,12 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 
 import { invoke } from "@tauri-apps/api/core";
-import type { CheatSetMarketFeeRequest, MarketFee } from "@tsukilabs/nil-bindings";
+import type {
+  CheatSetMarketFeeRequest,
+  CheatSetMarketVaultResourcesRequest,
+  MarketFee,
+  Resources,
+} from "@tsukilabs/nil-bindings";
 
 export async function cheatSetMarketFee(fee: MarketFee) {
   const req: CheatSetMarketFeeRequest = {
@@ -11,5 +16,13 @@ export async function cheatSetMarketFee(fee: MarketFee) {
   };
 
   await invoke("cheat_set_market_fee", { req });
-  await NIL.world.updateConfig();
+}
+
+export async function cheatSetMarketVaultResources(resources: Resources) {
+  const req: CheatSetMarketVaultResourcesRequest = {
+    world: NIL.world.getIdStrict(),
+    resources,
+  };
+
+  await invoke("cheat_set_market_vault_resources", { req });
 }

app/src/commands/cheat/market.ts

@@ -3,15 +3,26 @@
 
 import { invoke } from "@tauri-apps/api/core";
 import type {
+  BuyResourcesRequest,
   GetMarketFeeRequest,
   GetMarketFeeResponse,
   GetMarketRequest,
   GetMarketResponse,
   Resources,
   Ruler,
+  SellResourcesRequest,
   SendResourcesRequest,
 } from "@tsukilabs/nil-bindings";
 
+export async function buyResources(resources: Resources) {
+  const req: BuyResourcesRequest = {
+    world: NIL.world.getIdStrict(),
+    resources,
+  };
+
+  await invoke("buy_resources", { req });
+}
+
 export async function getMarket() {
   const req: GetMarketRequest = {
     world: NIL.world.getIdStrict(),
@@ -28,6 +39,15 @@ export async function getMarketFee() {
   return invoke<GetMarketFeeResponse>("get_market_fee", { req });
 }
 
+export async function sellResources(resources: Resources) {
+  const req: SellResourcesRequest = {
+    world: NIL.world.getIdStrict(),
+    resources,
+  };
+
+  await invoke("sell_resources", { req });
+}
+
 export async function sendResources(recipient: Ruler, resources: Resources) {
   const req: SendResourcesRequest = {
     world: NIL.world.getIdStrict(),

app/src/commands/market.ts

@@ -1,15 +1,47 @@
 // Copyright (C) Call of Nil contributors
 // SPDX-License-Identifier: AGPL-3.0-only
 
-import { asyncRef } from "@tb-dev/vue";
+import { computed } from "vue";
+import { throttle } from "es-toolkit/function";
+import { asyncRef, useMutex } from "@tb-dev/vue";
 import { MarketImpl } from "@/core/model/market/market";
+import type { Resources, Ruler } from "@tsukilabs/nil-bindings";
 
 export function useMarket() {
   const market = asyncRef(null, () => MarketImpl.load());
+  const throttledLoad = throttle(market.load, 1000);
+
+  const { locked, lock } = useMutex();
+
+  const loading = computed(() => {
+    return market.loading.value || locked.value;
+  });
+
+  async function buyResources(resources: Resources) {
+    await lock(async () => {
+      await market.state.value?.buy(resources);
+    });
+  }
+
+  async function sellResources(resources: Resources) {
+    await lock(async () => {
+      await market.state.value?.sell(resources);
+    });
+  }
+
+  async function sendResources(recipient: Ruler, resources: Resources) {
+    await lock(async () => {
+      await market.state.value?.send(recipient, resources);
+    });
+  }
 
   return {
     market: market.state,
-    loading: market.loading,
+    loading,
     load: market.load,
+    throttledLoad,
+    buyResources,
+    sellResources,
+    sendResources,
   };
 }

app/src/composables/market/useMarket.ts

@@ -0,0 +1,27 @@
+// Copyright (C) Call of Nil contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import type { DeepReadonly } from "es-toolkit/types";
+import type { Gold, MarketPrice } from "@tsukilabs/nil-bindings";
+
+export class MarketPriceImpl implements DeepReadonly<MarketPrice> {
+  public readonly food: Gold;
+  public readonly iron: Gold;
+  public readonly stone: Gold;
+  public readonly wood: Gold;
+
+  private constructor(price: MarketPrice) {
+    this.food = price.food;
+    this.iron = price.iron;
+    this.stone = price.stone;
+    this.wood = price.wood;
+  }
+
+  public static create(price: MarketPrice) {
+    if (price instanceof MarketPriceImpl) {
+      return price;
+    }
+
+    return new MarketPriceImpl(price);
+  }
+}