AI Core
Dokumentacja APILib: serwer

Pieniądze i bankowość

money.transfer między dwoma kontami, skrypt bankowy przez ai-core i rachunki przez dowolny skrypt rachunków, który działa.

TypeScript
import { money, banking, billing } from "@aicore8/lib/server";

money to każdy stan konta na serwerze: konta wczytanego gracza, wspólne konto pracy albo gangu, przelew, który przenosi pieniądze w jednej transakcji, i księga. Postać, która nie jest połączona, idzie przez characters. banking i billing to warstwy dla bankowego i rachunkowego skryptu serwera.

money

money.get

Stan konta wczytanego gracza na jednym koncie.

Strona: Serwer · Czeka: nie

Sygnatura
money.get(source: number, account: string): number | null
Lua
local balance = aiLib.money.get(source, account)

Parametry

Prop

Type

Zwraca

number | null: stan konta albo null, gdy gracz nie ma wczytanej postaci lub typ konta nie istnieje. Stany kont zapisanej postaci bierze się z characters.get.

Przykład

import { money, notify } from "@aicore8/lib/server";

export function tellBalance(source: number): void {
  const bank = money.get(source, "bank");
  notify(source, bank === null ? "Brak postaci" : `Bank: $${bank}`, bank === null ? "error" : "inform");
}

money.add, money.remove and money.set

Zmienia jedno konto wczytanego gracza, z wierszem księgi. To wywołania na nagrodę, cenę, pensję, którą płaci Twój skrypt.

Strona: Serwer · Czeka: nie

Sygnatura
money.add(source: number, account: string, amount: number, reason?: string): boolean
money.remove(source: number, account: string, amount: number, reason?: string): boolean
money.set(source: number, account: string, amount: number, reason?: string): boolean
Lua
local ok = aiLib.money.add(source, account, amount, reason)
local ok = aiLib.money.remove(source, account, amount, reason)
local ok = aiLib.money.set(source, account, amount, reason)

Parametry

Prop

Type

Zwraca

boolean: true, gdy zmiana się udała. false, gdy gracz nie ma wczytanej postaci, konto nie istnieje, kwota nie jest liczbą całkowitą powyżej 0, albo - przy remove - stan konta nie może zapłacić (chyba że typ konta może zejść poniżej zera).

Przykład

import { money, onClientCallback } from "@aicore8/lib/server";
import { fail } from "@aicore8/lib/shared";

onClientCallback("myshop:buyTools", { lock: true }, (source) => {
  if (!money.remove(source, "cash", 150, "shop:tools")) return fail("NOT_ENOUGH_CASH");
  // tutaj wydaj przedmiot
  return { ok: true };
});

Zapłata jednego gracza drugiemu nie jest remove plus add: błąd w połowie stworzyłby albo zniszczył pieniądze. Użyj money.transfer, to jedna transakcja bazy.

money.sharedGet

Stan konta pracy albo gangu - bank to to, co inne frameworki nazywają pieniędzmi firmy.

Strona: Serwer · Czeka: nie

Sygnatura
money.sharedGet(type: "job" | "gang", id: string, account: string): number | null
Lua
local balance = aiLib.money.sharedGet(type, id, account)

Parametry

Prop

Type

Zwraca

number | null: stan konta albo null, gdy ta praca albo gang nie ma takiego konta (nieznana praca albo typ konta, którego serwer nie ma).

money.sharedAdd and money.sharedRemove

Zmienia konto pracy albo gangu, z wierszem księgi - przychody i koszty firmy.

Strona: Serwer · Czeka: nie

Sygnatura
money.sharedAdd(type: "job" | "gang", id: string, account: string, amount: number, reason?: string): boolean
money.sharedRemove(type: "job" | "gang", id: string, account: string, amount: number, reason?: string): boolean
Lua
local ok = aiLib.money.sharedAdd(type, id, account, amount, reason)
local ok = aiLib.money.sharedRemove(type, id, account, amount, reason)

Zwraca

boolean: true, gdy zmiana się udała, false przy nieznanej pracy albo gangu, braku konta, błędnej kwocie albo koncie, które nie może zapłacić.

Przykład

import { money } from "@aicore8/lib/server";

/** Kontrakt miasta, który zarabia warsztat, i opłata, którą płaci za części. */
export function contractDone(job: string, pay: number, parts: number): boolean {
  if (!money.sharedAdd("job", job, "bank", pay, "city contract")) return false;
  return money.sharedRemove("job", job, "bank", parts, "parts");
}

money.transfer

Przenosi pieniądze z jednego konta na drugie w jednej transakcji bazy danych, z wierszem w księdze po obu stronach. Używaj go dla wszystkiego, gdzie pieniądze nie mogą pojawić się ani zniknąć w połowie: płatność innemu graczowi, premia wypłacana przez pracę, opłata.

Strona: Serwer · Czeka: nie

Sygnatura
money.transfer(from: MoneyRef, to: MoneyRef, amount: number, reason?: string, fee?: number): boolean
Lua
local ok = aiLib.money.transfer(from, to, amount, reason, fee)

Parametry

Prop

Type

Zwracana wartość

boolean: true, gdy oba wiersze zostały zapisane. false, gdy kwota nie jest liczbą całkowitą, brakuje konta, oba są tym samym kontem albo from nie może zapłacić amount plus fee.

Przykład

import { onClientCallback, money, nearestPlayerTo, notify } from "@aicore8/lib/server";
import { fail, oneArg, readInt } from "@aicore8/lib/shared";

onClientCallback("my-cash:give", { args: oneArg((v) => readInt(v, 1, 100_000)), lock: true }, (source, amount) => {
  const target = nearestPlayerTo(source, 2);
  if (target === null) return fail("NOBODY_NEAR");
  if (!money.transfer({ source, account: "cash" }, { source: target, account: "cash" }, amount, "give:cash"))
    return fail("NOT_ENOUGH_CASH");
  notify(target, `You received $${amount}`, "success");
  return { ok: true };
});

money.history

Wiersze księgi konta, najnowsze pierwsze: co się ruszyło, stan konta po tym, powód, kto to zrobił i kiedy. Działa dla konta gracza, konta pracy albo gangu i konta zapisanej postaci.

Strona: Serwer · Czeka: tak

Sygnatura
money.history(account: LedgerRef, query?: LedgerQuery): Promise<LedgerPage>
Lua
local page = aiLib.money.history(account, query)

Parametry

Prop

Type

Zwraca

LedgerPage: rows i next, które podajesz jako before (null na ostatniej stronie). ai-core zapisuje wiersz chwilę po zmianie, więc najnowszy może być kilka milisekund za stanem konta.

Przykład

import { money } from "@aicore8/lib/server";

/** Ostatnie 20 wierszy bankowych zapisanej postaci. */
export async function statement(charId: number) {
  const page = await money.history({ owner: "character", id: String(charId), account: "bank" }, { limit: 20 });
  return page.rows.map((r) => `${r.at}: ${r.amount} (${r.reason})`);
}

banking

banking rozmawia ze skryptem bankowym przez warstwę bankowości ai-core. Same pieniądze pracy zawsze przechodzą przez money albo eksporty ai-core.

banking.open

Otwiera ekran skryptu bankowego dla gracza.

Strona: Serwer · Czeka: nie

Sygnatura
banking.open(source: number): boolean
Lua
local ok = aiLib.banking.open(source)

Zwraca true, gdy otwarto. false, gdy skryptu nie da się otworzyć z zewnątrz albo żaden nie działa.

onClientCallback("my-atm:open", (source) => (banking.open(source) ? { ok: true } : fail("BANK_UNAVAILABLE")));

banking.societyBalance

Saldo konta firmy pracy, do wyświetlenia. W trybie kont core ai-core to konto pracy w ai-core; w trybie own własne konto skryptu bankowego.

Strona: Serwer · Czeka: nie

Sygnatura
banking.societyBalance(job: string): number | null
Lua
local balance = aiLib.banking.societyBalance(job) -- liczba albo nil

Zwraca saldo albo null (Lua nil), gdy żaden nie działa albo skrypt go nie prowadzi.

const balance = banking.societyBalance("mechanic") ?? 0;

banking.provider

Strona: Serwer · Czeka: nie

Sygnatura
banking.provider(): string | null
Lua
local name = aiLib.banking.provider()

Zwraca skrypt bankowy, którego używa warstwa, albo null.

console.log(`banking through ${banking.provider() ?? "nothing"}`);

billing

billing wysyła rachunki przez dowolny skrypt rachunków, który działa; bez niego przez własne rachunki ai-core (gracz płaci z listy na ekranie, pieniądze przechodzą, gdy zapłaci). Teksty są już przetłumaczone.

billing.send

Wysyła rachunek od pracy (mandaty, opłaty za usługi) albo od gracza.

Strona: Serwer · Czeka: nie

Sygnatura
billing.send(bill: BillRequest): boolean
Lua
local ok = aiLib.billing.send(bill)

BillRequest

Prop

Type

Zwracana wartość

boolean: true, gdy wysłano, false, gdy nieprawidłowy albo odrzucony.

Przykład

import { billing, nearestPlayerTo, online } from "@aicore8/lib/server";
import { fail } from "@aicore8/lib/shared";

function fine(officer: number, amount: number) {
  if (!online.onDutyIn(officer, ["police"])) return fail("NOT_ON_DUTY");
  const target = nearestPlayerTo(officer, 3);
  if (target === null) return fail("NOBODY_NEAR");
  return billing.send({ to: target, amount, label: "Speeding", from: officer, job: "police" })
    ? { ok: true }
    : fail("BILL_FAILED");
}

billing.unpaid

Otwarte rachunki gracza.

Strona: Serwer · Czeka: tak (Promise w TypeScript, w Lua wstrzymuje wątek)

Sygnatura
billing.unpaid(source: number): Promise<UnpaidBill[] | null>
Lua
local bills = aiLib.billing.unpaid(source) -- table[] albo nil, wywołuj wewnątrz wątku

Zwraca UnpaidBill[] (id, label, amount nadal do zapłaty, sender) albo null, gdy skrypt rachunków nie potrafi ich wymienić.

const bills = await billing.unpaid(source);
const owed = bills?.reduce((sum, bill) => sum + bill.amount, 0) ?? 0;

billing.pay

Gracz płaci jeden ze swoich otwartych rachunków.

Strona: Serwer · Czeka: nie

Sygnatura
billing.pay(source: number, id: string): boolean
Lua
local ok = aiLib.billing.pay(source, id)

Prop

Type

Zwraca true, gdy zapłacono. false, gdy odrzucono (za mało pieniędzy, nieznany rachunek) albo skrypt rachunków przyjmuje płatności tylko na własnym ekranie.

if (!billing.pay(source, billId)) return fail("PAY_FAILED");

billing.provider

Strona: Serwer · Czeka: nie

Sygnatura
billing.provider(): string | null
Lua
local name = aiLib.billing.provider()

Zwraca skrypt rachunków, do którego trafiają rachunki, "ai-core" dla własnych rachunków ai-core.

if (billing.provider() === "ai-core") console.log("using ai-core's own bills");

Na tej stronie