Périphériques

$\text{[math]}$ Logistique de Create

Les colis de Create pilotés par un programme : Emballeurs, Crapauports et Boîtes aux lettres, le Commandeur à redstone, le Téléscripteur de stock d'un réseau de stockage, et les boutiques sur nappe.

Create déplace les objets dans des Colis en carton : un Emballeur les emballe, les tapis roulants, les roues à chaîne roulante et les trains les transportent, et l'adresse écrite sur chaque colis dit où il va. Un ordinateur prend part à tout cela : il emballe à la demande, change l'adresse des colis, commande des objets à tout un réseau de stockage, et tient une boutique.

Brass

local teles = peripheral.find("stock_ticker")
local n = teles.request("Atelier", {name = "minecraft:iron_ingot", count = 64})
print(n .. " lingots de fer en route")

Méthodes

`packager.make_package()`	Emballe maintenant l'inventaire derrière l'Emballeur, comme le ferait une impulsion de redstone. Si l'ordinateur a donné une adresse avec `set_address`, le colis la reçoit.
`packager.list()`	Ce que l'Emballeur emballerait : les objets de l'inventaire derrière lui, lus comme avec `inventory.list()`.
`packager.get(slot)`	Un emplacement de l'inventaire derrière l'Emballeur. Un emplacement en dehors de l'inventaire arrête le programme avec `bad argument #1 to 'get' (slot 30 out of range, 1 to 27)`.
`packager.address()`	L'adresse que recevront les colis faits par `make_package`.
`packager.set_address(address)`	Règle l'adresse des colis que cet ordinateur fait avec `make_package`. Elle ne change ni le panneau, ni l'adresse des colis que l'Emballeur fait de lui-même.
`packager.package()`	Le colis que l'Emballeur tient en ce moment : celui qu'il vient de faire, avant qu'il parte.
`packager.set_package_address(address)`	Change l'adresse du colis que tient l'Emballeur, avant qu'il parte. Quand il n'en tient aucun, le programme s'arrête avec `the packager holds no package`.
`port.address()`	L'adresse dont le port attrape les colis. Create permet `` dedans (`"Cuisine"`), et une adresse vide attrape les colis qui n'en ont pas.
`port.set_address(address)`	Change l'adresse dont le port attrape les colis, comme le fait son interface.
`port.configuration()`	Ce que fait le port :
`port.set_configuration(mode)`	Choisit ce que fait le port. Un autre mot arrête le programme ; `"send_recieve"`, l'orthographe du périphérique ComputerCraft de Create, fonctionne aussi.
`port.list()`	Les colis qui attendent dans le port, lus comme avec `inventory.list()`.
`port.get(slot)`	Un emplacement du port. Un emplacement en dehors arrête le programme, comme avec `packager.get()`.
`req.request()`	Envoie la commande maintenant, comme une impulsion de redstone. Une fois par tick au plus : un deuxième appel dans le même tick échoue et dit d'attendre (`sleep(0)`).
`req.set_request(...)`	Remplace la commande. Un identifiant seul demande un objet.
`req.set_crafting_request(count, ...)`	Commande des ingrédients avec leur recette, pour une ligne de fabrication automatique.
`req.get_request()`	La commande qu'envoie le Commandeur, rangée par case comme elle a été donnée : un motif de fabrication garde ses trous, donc `set_crafting_request(1, "oak_planks", nil, "stick")` se relit avec une case 1 et une case 3, sans case 2. Parcourez-la avec `pairs`, qui saute les trous.
`req.configuration()`	Si le Commandeur envoie ce qu'il y a (`"allow_partial"`) ou attend que tout soit en stock (`"strict"`).
`req.set_configuration(mode)`	Choisit le mode. Un autre mot arrête le programme.
`req.address()`	Où vont les colis de la commande.
`req.set_address(address)`	Change l'endroit où vont les colis de la commande.
`ticker.stock()`	Tout le stock du réseau. `count` est le total de cet objet dans tous les inventaires, souvent bien plus que 64.
`ticker.stock_item(n)`	Une entrée du stock, sans construire toute la liste. L'ordre de la liste change quand le stock change.
`ticker.request(address, ...)`	Envoie des objets du réseau à une adresse, dans des colis. Une fois par tick au plus, car le stock qu'il lit n'est compté qu'une fois par tick : un deuxième appel dans le même tick échoue et dit d'attendre (`sleep(0)`).
`ticker.list()`	Les paiements que le Téléscripteur de stock a reçus des boutiques de son réseau, lus comme avec `inventory.list()`.
`ticker.get(slot)`	Un emplacement de paiement. Un emplacement en dehors arrête le programme, comme avec `packager.get()`.
`shop.shop()`	Si la nappe vend quelque chose. Toutes les autres méthodes, sauf `set_wares`, demandent une boutique : sur une simple nappe, elles arrêtent le programme avec `this table cloth is not a shop`.
`shop.wares()`	Les marchandises de la boutique.
`shop.set_wares(...)`	Règle ce que donne un achat, et fait de la nappe une boutique. Appelée sans rien, elle refait de la boutique une simple nappe.
`shop.price_item()`	L'objet de paiement. Son `count` vaut 1 : le prix lui-même est `price_count()`.
`shop.set_price_item(id)`	Règle l'objet demandé en paiement. Une boutique sans objet de paiement refuse de vendre.
`shop.price_count()`	Le prix, en objets de paiement.
`shop.set_price_count(n)`	Règle le prix, en objets de paiement.
`shop.address()`	L'adresse des colis de marchandises : en général un Crapauport ou une Boîte aux lettres au comptoir de la boutique.
`shop.set_address(address)`	Change l'endroit où la boutique envoie ce qu'elle vend.

Installation

Les blocs et leurs types. Posez le bloc contre une face de l'ordinateur, ou contre un Câble de données de son réseau (à partir du Mini-ordinateur), puis prenez-le, par exemple avec peripheral.find("stock_ticker"). Voir Périphériques.

type	bloc	méthodes
`packager`	Emballeur	Emballeur
`repackager`	Réemballeur	les mêmes que l'Emballeur
`frogport`	Crapauport à colis	ports à colis
`postbox`	Boîte aux lettres, de toute couleur	ports à colis
`redstone_requester`	Commandeur à redstone	Commandeur à redstone
`stock_ticker`	Téléscripteur de stock	Téléscripteur de stock
`table_cloth`	Nappe de toute couleur, Couvre-table d'andésite, de laiton et de cuivre	boutique

Les objets. Un objet que nomme un programme est son identifiant, comme "minecraft:iron_ingot" ou "create:andesite_alloy" (un nom sans : veut dire minecraft:). Un identifiant qui ne désigne aucun objet arrête le programme avec bad argument to 'set_request' (unknown item 'minecraft:iron_ingott'). Les objets reviennent sous forme de tables {name =, count =, display =}, comme sur la page Inventaires.

Les adresses. Un colis porte une adresse, un court texte. Les Filtres de colis, les Crapauports et les Boîtes aux lettres la lisent pour envoyer le colis dans la bonne direction, et Create permet * pour n'importe quel texte dans les leurs. Les adresses que donne un programme sont coupées à 128 caractères.

Pas d'évènements : demandez en boucle. Les périphériques ComputerCraft de Create envoient des évènements quand un colis est fait ou reçu. Brass n'a pas d'évènements de périphériques : regardez de nouveau package() ou list() toutes les secondes environ.

Quand un bloc est cassé, ses méthodes arrêtent le programme avec packager removed, package port removed, redstone requester removed, stock ticker removed ou table cloth removed.

Emballeur

Un Emballeur emballe dans un colis les objets de l'inventaire derrière lui quand il reçoit une impulsion de redstone, et déballe dans cet inventaire les colis qu'il reçoit. Un Réemballeur (type repackager) a les mêmes méthodes, et peripheral.find("packager") le trouve aussi.

Quelle adresse reçoit un colis

L'Emballeur écrit l'adresse du panneau posé sur lui. Avec set_address, l'ordinateur donne une autre adresse, mais **seulement aux colis qu'il fait lui-même avec make_package**. Les colis que l'Emballeur fait sans l'ordinateur (une impulsion de redstone) reçoivent toujours l'adresse du panneau, et ceux qu'il emballe pour une commande du réseau reçoivent l'adresse de cette commande. (Dans Create, seul un ordinateur ComputerCraft change les autres.)

`packager.make_package()`

→ boolean⚙ coût 8

Emballe maintenant l'inventaire derrière l'Emballeur, comme le ferait une impulsion de redstone. Si l'ordinateur a donné une adresse avec set_address, le colis la reçoit.

Renvoie

boolean: vrai quand un colis a été fait

Brass

local emb = peripheral.find("packager")
emb.set_address("Fonderie")
if emb.make_package() then
  print("un colis part pour la Fonderie")
end

Elle renvoie false, sans rien emballer, quand :

l'Emballeur tient encore le colis précédent (un tapis roulant, une chute ou un Crapauport doit d'abord l'emporter) ;
l'inventaire derrière lui est vide, ou absent ;
il a fait un colis il y a moins de deux secondes, comme avec un bouton ;
une Liaison de stock est posée sur lui : il ne travaille alors que pour son réseau logistique.

Voir aussi packager.set_address() packager.package()

`packager.list()`

→ table⚙ coût 1 + 1 par emplacement

Ce que l'Emballeur emballerait : les objets de l'inventaire derrière lui, lus comme avec inventory.list().

Renvoie

table: les piles de l'inventaire derrière lui, indexées par numéro d'emplacement ; les emplacements vides manquent

Sans inventaire derrière lui, le programme s'arrête avec the packager has no inventory behind it.

Voir aussi packager.get() inventory.list()

`packager.get(slot)`

→ table|nil

Un emplacement de l'inventaire derrière l'Emballeur. Un emplacement en dehors de l'inventaire arrête le programme avec bad argument #1 to 'get' (slot 30 out of range, 1 to 27).

Paramètres

slot number: un emplacement de l'inventaire derrière lui, à partir de 1

Renvoie

table|nil: la pile de cet emplacement, ou nil quand il est vide

Voir aussi packager.list()

`packager.address()`

→ string

L'adresse que recevront les colis faits par make_package.

Renvoie

string: l'adresse que cet ordinateur a donnée, sinon celle du panneau de l'Emballeur, "" sans aucune des deux

Voir aussi packager.set_address()

`packager.set_address(address)`

Règle l'adresse des colis que cet ordinateur fait avec make_package. Elle ne change ni le panneau, ni l'adresse des colis que l'Emballeur fait de lui-même.

Paramètres

address string|nil: l'adresse, coupée à 128 caractères ; nil pour revenir à celle du panneau

Voir aussi packager.address() packager.make_package()

`packager.package()`

→ table|nil

Le colis que l'Emballeur tient en ce moment : celui qu'il vient de faire, avant qu'il parte.

Renvoie

table|nil: le colis que tient l'Emballeur, ou nil

champ	contenu
`address`	l'adresse du colis, `""` quand il n'en a pas
`items`	ce qu'il contient : une liste de `{name =, count =, display =}`
`order`	seulement pour un colis fait pour une commande du réseau (Téléscripteur de stock, Commandeur à redstone)

order contient id (le numéro de la commande), index (la place de ce colis parmi ceux que cet Emballeur fait pour la commande, à partir de 1), final (vrai pour son dernier), link_index et final_link (la même chose, parmi les Emballeurs du réseau qui se partagent la commande), et items, tous les objets de la commande.

Un colis ne reste qu'un instant : demandez souvent (toutes les 0,1 seconde) pour les voir tous.

Brass

local emb = peripheral.find("packager")
local colis = emb.package()
if colis then
  print("pour " .. colis.address .. " : " .. #colis.items .. " piles")
end

Voir aussi packager.set_package_address()

`packager.set_package_address(address)`

Change l'adresse du colis que tient l'Emballeur, avant qu'il parte. Quand il n'en tient aucun, le programme s'arrête avec the packager holds no package.

Paramètres

address string: la nouvelle adresse, coupée à 128 caractères

Un Emballeur qui vide le coffre d'une mine, et envoie à l'entrepôt ce qui n'a pas d'adresse :

Brass

local emb = peripheral.find("packager")
while true do
  local colis = emb.package()
  if colis and colis.address == "" then
    emb.set_package_address("Entrepôt")
  end
  sleep(0.1)
end

Voir aussi packager.package()

Ports à colis

Un Crapauport à colis (type frogport) est accroché à une roue à chaîne roulante ; une Boîte aux lettres (type postbox) se tient près d'une Station de train. Chacun a une adresse : il attrape les colis adressés à elle, et envoie plus loin les colis qu'on met dedans. Leurs méthodes sont les mêmes, écrites port ici.

Brass

local port = peripheral.find("frogport")
print("ce crapaud attrape les colis pour " .. port.address())

`port.address()`

→ string

L'adresse dont le port attrape les colis. Create permet * dedans ("Cuisine*"), et une adresse vide attrape les colis qui n'en ont pas.

Renvoie

string: l'adresse dont il attrape les colis

Voir aussi package_port.set_address()

`port.set_address(address)`

Change l'adresse dont le port attrape les colis, comme le fait son interface.

Paramètres

address string: la nouvelle adresse, coupée à 128 caractères

Voir aussi package_port.address()

`port.configuration()`

→ string|nil

Ce que fait le port :

Renvoie

string|nil: "send_receive", "send", ou nil quand le port n'a pas de cible

"send_receive" : il attrape les colis adressés à lui, et envoie les autres plus loin ;
"send" : il envoie seulement les colis qu'on met dedans, et n'attrape rien ;
nil : il n'est pas encore relié à une roue à chaîne roulante ou à une Station de train.

Voir aussi package_port.set_configuration()

`port.set_configuration(mode)`

→ boolean

Choisit ce que fait le port. Un autre mot arrête le programme ; "send_recieve", l'orthographe du périphérique ComputerCraft de Create, fonctionne aussi.

Paramètres

mode string: "send_receive" ou "send"

Renvoie

boolean: true, ou false quand le port n'a pas de cible

Voir aussi package_port.configuration()

`port.list()`

→ table⚙ coût 1 + 1 par emplacement

Les colis qui attendent dans le port, lus comme avec inventory.list().

Renvoie

table: les colis que tient le port, indexés par numéro d'emplacement ; les emplacements vides manquent

Brass

local port = peripheral.find("postbox")
local connus = 0
while true do
  local nombre = 0
  for _, pile in pairs(port.list()) do
    nombre = nombre + pile.count
  end
  if nombre > connus then
    print("Vous avez du courrier : " .. nombre .. " colis")
  end
  connus = nombre
  sleep(5)
end

Voir aussi package_port.get()

`port.get(slot)`

→ table|nil

Un emplacement du port. Un emplacement en dehors arrête le programme, comme avec packager.get().

Paramètres

slot number: un emplacement du port, à partir de 1

Renvoie

table|nil: le colis de cet emplacement, ou nil quand il est vide

Voir aussi package_port.list()

Commandeur à redstone

Un Commandeur à redstone appartient au réseau logistique d'une Liaison de stock (faites clic droit sur la Liaison de stock avec lui avant de le poser). À chaque impulsion de redstone, il commande les mêmes objets au réseau, envoyés à son adresse. Un programme change la commande et l'envoie sans redstone.

`req.request()`

⚙ coût 8

Envoie la commande maintenant, comme une impulsion de redstone. Une fois par tick au plus : un deuxième appel dans le même tick échoue et dit d'attendre (sleep(0)).

En mode "strict", rien ne part tant que tous les objets ne sont pas en stock ; en mode "allow_partial", ce qu'il y a part.

Voir aussi redstone_requester.set_request() redstone_requester.set_configuration()

`req.set_request(...)`

Remplace la commande. Un identifiant seul demande un objet.

Paramètres

... string|table: jusqu'à 9 objets : un identifiant, {name =, count =} avec un nombre de 1 à 256, ou nil pour un emplacement vide

Brass

local dem = peripheral.find("redstone_requester")
dem.set_request("minecraft:bread", {name = "minecraft:coal", count = 32})

Plus de 9 objets arrête le programme avec too many items for 'set_request' (9 at most), un nombre hors limites avec bad argument #2 to 'set_request' (count 1 to 256).

Voir aussi redstone_requester.get_request() redstone_requester.request()

`req.set_crafting_request(count, ...)`

Commande des ingrédients avec leur recette, pour une ligne de fabrication automatique.

Paramètres

count number: combien de fois fabriquer, de 1 à 256
... string|table: les 9 cases de la grille de fabrication, ligne par ligne : un identifiant, {name =, count =}, ou nil pour une case vide

Les objets sont envoyés comme avec set_request, la recette jointe : à l'arrivée, un Réemballeur fait un colis par fabrication, et un Emballeur qui les déballe dans des Établis mécaniques pose chaque objet sur sa case. Le nombre d'un objet est combien la commande en demande : donnez donc à chaque case autant d'objets que de fabrications.

Brass

local dem = peripheral.find("redstone_requester")
local planche = {name = "minecraft:oak_planks", count = 4}
-- 4 établis : des planches sur les deux premières cases des deux premières lignes
dem.set_crafting_request(4, planche, planche, nil, planche, planche)

Voir aussi redstone_requester.set_request()

`req.get_request()`

→ table

La commande qu'envoie le Commandeur, rangée par case comme elle a été donnée : un motif de fabrication garde ses trous, donc set_crafting_request(1, "oak_planks", nil, "stick") se relit avec une case 1 et une case 3, sans case 2. Parcourez-la avec pairs, qui saute les trous.

Renvoie

table: les objets de la commande, des {name =, count =, display =} rangés par case, de 1 à 9 ; les cases vides manquent

Brass

local dem = peripheral.find("redstone_requester")
for case, objet in pairs(dem.get_request()) do
  print(case .. " : " .. objet.count .. " x " .. objet.display)
end

Voir aussi redstone_requester.set_request()

`req.configuration()`

→ string

Si le Commandeur envoie ce qu'il y a ("allow_partial") ou attend que tout soit en stock ("strict").

Renvoie

string: "allow_partial" ou "strict"

Voir aussi redstone_requester.set_configuration()

`req.set_configuration(mode)`

Choisit le mode. Un autre mot arrête le programme.

Paramètres

mode string: "allow_partial" ou "strict"

Voir aussi redstone_requester.configuration()

`req.address()`

→ string

Où vont les colis de la commande.

Renvoie

string: l'adresse où vont ses colis

Voir aussi redstone_requester.set_address()

`req.set_address(address)`

Change l'endroit où vont les colis de la commande.

Paramètres

address string: la nouvelle adresse, coupée à 128 caractères

Garder les fours approvisionnés : le coffre de charbon à gauche de l'ordinateur ne se vide jamais.

Brass

local dem = peripheral.find("redstone_requester")
local coffre = peripheral.wrap("left")
dem.set_request({name = "minecraft:coal", count = 64})
dem.set_address("Fours")
dem.set_configuration("allow_partial")
while true do
  if coffre.count("minecraft:coal") < 32 then
    dem.request()
    sleep(30)  -- le temps que le colis arrive
  end
  sleep(5)
end

Voir aussi redstone_requester.address()

Téléscripteur de stock

Un Téléscripteur de stock rejoint le réseau logistique d'une Liaison de stock : il voit chaque objet des inventaires que joignent les Emballeurs de ce réseau. Il en envoie à n'importe quelle adresse, comme le fait son magasinier (une créature assise devant lui) pour les joueurs, et il garde les paiements des boutiques.

`ticker.stock()`

→ table⚙ coût 16 + 1 par sorte d'objet

Tout le stock du réseau. count est le total de cet objet dans tous les inventaires, souvent bien plus que 64.

Renvoie

table: chaque objet du réseau, une liste de {name =, count =, display =}, une entrée par sorte d'objet

Brass

local teles = peripheral.find("stock_ticker")
for _, entree in ipairs(teles.stock()) do
  print(entree.count .. " x " .. entree.display)
end

Voir aussi stock_ticker.stock_item() stock_ticker.request()

`ticker.stock_item(n)`

→ table|nil

Une entrée du stock, sans construire toute la liste. L'ordre de la liste change quand le stock change.

Paramètres

n number: la place de l'entrée dans la liste, à partir de 1

Renvoie

table|nil: l'entrée n de la liste que donne stock(), ou nil après sa fin

Voir aussi stock_ticker.stock()

`ticker.request(address, ...)`

→ number⚙ coût 32 + 1 par sorte d'objet, une fois de plus par filtre

Envoie des objets du réseau à une adresse, dans des colis. Une fois par tick au plus, car le stock qu'il lit n'est compté qu'une fois par tick : un deuxième appel dans le même tick échoue et dit d'attendre (sleep(0)).

Paramètres

address string: où vont les colis, coupée à 128 caractères
... table: des filtres {name =, count =} ; name est un identifiant d'objet (un simple nom est un objet de Minecraft), * et ? permis, 256 caractères au plus ; sans count, tout

Renvoie

number: combien d'objets ont été demandés en tout, 0 quand rien ne correspondait

Chaque filtre choisit des objets du stock :

name est comparé à l'identifiant complet : "minecraft:iron_ingot". * remplace n'importe quel texte et ? un caractère : "minecraft:*_log" prend toutes les sortes de bûches, "create:*" tout ce qui vient de Create. Un simple nom sans : est un objet de Minecraft, comme partout ailleurs : "iron_ingot" est "minecraft:iron_ingot". Un motif est comparé à l'identifiant entier : "*_ingot" prend les lingots de tous les mods.
count est le maximum à prendre, sur tous les objets dont le nom correspond, dans l'ordre de stock(). Sans lui, le filtre les prend tous.
Les filtres se servent l'un après l'autre : un second filtre ne trouve que ce que le premier a laissé.

Brass

local teles = peripheral.find("stock_ticker")
local n = teles.request("Atelier",
  {name = "minecraft:iron_ingot", count = 64},
  {name = "minecraft:*_log", count = 128},
  {name = "create:andesite_alloy"})
print(n .. " objets en route vers l'Atelier")

Elle renvoie combien d'objets ont été demandés. Ils partent des Emballeurs du réseau : ils arrivent donc un peu plus tard, en plusieurs colis. Un filtre qui n'est pas une table avec un name arrête le programme avec bad argument #3 to 'request' ({name = id, count = n} expected).

Voir aussi stock_ticker.stock()

`ticker.list()`

→ table⚙ coût 1 + 1 par emplacement

Les paiements que le Téléscripteur de stock a reçus des boutiques de son réseau, lus comme avec inventory.list().

Renvoie

table: les paiements qu'il garde, indexés par numéro d'emplacement ; les emplacements vides manquent

Voir aussi stock_ticker.get()

`ticker.get(slot)`

→ table|nil

Un emplacement de paiement. Un emplacement en dehors arrête le programme, comme avec packager.get().

Paramètres

slot number: un emplacement de paiement, à partir de 1

Renvoie

table|nil: la pile de cet emplacement, ou nil quand il est vide

Voir aussi stock_ticker.list()

Boutique sur nappe

Une Nappe qui vend quelque chose est une boutique. Les joueurs cliquent dessus pour remplir une Liste de courses, paient auprès du magasinier d'un Téléscripteur de stock, et les marchandises quittent le réseau dans des colis pour l'adresse de la boutique ; le paiement reste dans le Téléscripteur de stock.

Créez d'abord la boutique en jeu

La boutique doit connaître son Téléscripteur de stock. Create les relie quand vous créez la boutique en jeu : clic droit sur le magasinier en tenant une Nappe, choix des marchandises, puis pose de la nappe. Un programme change ensuite ses marchandises, son prix et son adresse.

`shop.shop()`

→ boolean

Si la nappe vend quelque chose. Toutes les autres méthodes, sauf set_wares, demandent une boutique : sur une simple nappe, elles arrêtent le programme avec this table cloth is not a shop.

Renvoie

boolean: vrai quand la nappe est une boutique (elle a des marchandises)

Voir aussi table_cloth.set_wares()

`shop.wares()`

→ table

Les marchandises de la boutique.

Renvoie

table: ce que donne un achat, une liste de {name =, count =, display =}

Brass

local boutique = peripheral.find("table_cloth")
for _, article in ipairs(boutique.wares()) do
  print(article.count .. " x " .. article.display)
end

Voir aussi table_cloth.set_wares()

`shop.set_wares(...)`

Règle ce que donne un achat, et fait de la nappe une boutique. Appelée sans rien, elle refait de la boutique une simple nappe.

Paramètres

... string|table: jusqu'à 9 objets : un identifiant ou {name =, count =} avec un nombre de 1 à 256

Brass

local boutique = peripheral.find("table_cloth")
boutique.set_wares({name = "minecraft:bread", count = 8}, "minecraft:cake")

Des objets posés sur la nappe par un joueur arrêtent le programme avec the table cloth holds items: take them off first.

Voir aussi table_cloth.wares() table_cloth.shop()

`shop.price_item()`

→ table|nil

L'objet de paiement. Son count vaut 1 : le prix lui-même est price_count().

Renvoie

table|nil: l'objet demandé en paiement, {name =, count =, display =}, ou nil quand il n'y en a pas

Voir aussi table_cloth.set_price_item() table_cloth.price_count()

`shop.set_price_item(id)`

Règle l'objet demandé en paiement. Une boutique sans objet de paiement refuse de vendre.

Paramètres

id string|nil: un identifiant d'objet ; nil retire le prix

Voir aussi table_cloth.price_item()

`shop.price_count()`

→ number

Le prix, en objets de paiement.

Renvoie

number: combien d'objets de paiement coûte un achat

Voir aussi table_cloth.set_price_count()

`shop.set_price_count(n)`

Règle le prix, en objets de paiement.

Paramètres

n number|nil: de 1 à 100 (ramené dans ces limites) ; nil donne 1

Voir aussi table_cloth.price_count()

`shop.address()`

→ string

L'adresse des colis de marchandises : en général un Crapauport ou une Boîte aux lettres au comptoir de la boutique.

Renvoie

string: où la boutique envoie ce qu'elle vend

Voir aussi table_cloth.set_address()

`shop.set_address(address)`

Change l'endroit où la boutique envoie ce qu'elle vend.

Paramètres

address string: la nouvelle adresse, coupée à 128 caractères

Une boulangerie dont le prix suit le stock : le pain est plus cher quand il en reste peu.

Brass

local boutique = peripheral.find("table_cloth")
local teles = peripheral.find("stock_ticker")
boutique.set_price_item("minecraft:emerald")
while true do
  local pain = 0
  for _, entree in ipairs(teles.stock()) do
    if entree.name == "minecraft:bread" then
      pain = entree.count
    end
  end
  if pain < 64 then
    boutique.set_price_count(3)
  else
    boutique.set_price_count(1)
  end
  sleep(30)
end

Voir aussi table_cloth.address()

#Installation

#Emballeur

packager.make_package()

packager.list()

packager.get(slot)

packager.address()

packager.set_address(address)

packager.package()

packager.set_package_address(address)

#Ports à colis

port.address()

port.set_address(address)

port.configuration()

port.set_configuration(mode)

port.list()

port.get(slot)

#Commandeur à redstone

req.request()

req.set_request(...)

req.set_crafting_request(count, ...)

req.get_request()

req.configuration()

req.set_configuration(mode)

req.address()

req.set_address(address)

#Téléscripteur de stock

ticker.stock()

ticker.stock_item(n)

ticker.request(address, ...)

ticker.list()

ticker.get(slot)

#Boutique sur nappe

shop.shop()

shop.wares()

shop.set_wares(...)

shop.price_item()

shop.set_price_item(id)

shop.price_count()

shop.set_price_count(n)

shop.address()

shop.set_address(address)

Installation

Emballeur

`packager.make_package()`

`packager.list()`

`packager.get(slot)`

`packager.address()`

`packager.set_address(address)`

`packager.package()`

`packager.set_package_address(address)`

Ports à colis

`port.address()`

`port.set_address(address)`

`port.configuration()`

`port.set_configuration(mode)`

`port.list()`

`port.get(slot)`

Commandeur à redstone

`req.request()`

`req.set_request(...)`

`req.set_crafting_request(count, ...)`

`req.get_request()`

`req.configuration()`

`req.set_configuration(mode)`

`req.address()`

`req.set_address(address)`

Téléscripteur de stock

`ticker.stock()`

`ticker.stock_item(n)`

`ticker.request(address, ...)`

`ticker.list()`

`ticker.get(slot)`

Boutique sur nappe

`shop.shop()`

`shop.wares()`

`shop.set_wares(...)`

`shop.price_item()`

`shop.set_price_item(id)`

`shop.price_count()`

`shop.set_price_count(n)`

`shop.address()`

`shop.set_address(address)`