Create: Computing AgesDoc Brass
Périphériques

Blocs de canon

Les culasses, chargeur, perceuse, moule, obus et cartouches de Create Big Cannons lus par un ordinateur : ouvrir la culasse au bon moment, régler chaque détonateur avant le chargement, surveiller une fonderie de canons.

Il faut Create Big Cannons

Tous les blocs de cette page appartiennent à Create Big Cannons. Sans ce mod, ces blocs n'existent pas, et peripheral.find("sliding_breech") renvoie nil.

Autour d'un canon de Create Big Cannons, bien des blocs ont un rôle : la culasse qui s'ouvre pour laisser entrer les munitions, le chargeur de canon qui les enfonce dans le fût, le détonateur qui décide quand un obus éclate et, à la fonderie, le moule où se coule un fût et la perceuse qui l'alèse. Un ordinateur les lit tous et règle ce qu'un joueur règle à la main : il ouvre la culasse au bon moment, attend le chargeur, donne à chaque obus un temps de détonateur calculé pour sa cible, et fait tourner une fonderie sans surveillance. Le canon lui-même, sur son support, a sa propre page : Supports de canon.

La traduction française de Big Cannons est incomplète : les blocs qu'elle ne traduit pas gardent leur nom anglais en jeu, indiqué entre parenthèses.

Bloc (nom en jeu)type de périphériquece qu'il lit ou règle
Culasse coulissante (fonte, bronze, acier)sliding_breechde combien elle est ouverte, si quelque chose l'empêche de fermer
Culasse à vis (acier, nethersteel)screw_breechde combien elle est déverrouillée
Chargeur de canoncannon_loaderde combien sa tige est sortie, si elle bouge, pourquoi elle n'a pas pu
Perceuse de canoncannon_drilljusqu'où elle a percé, pourquoi elle s'est arrêtée, son eau
Moule de canoncannon_castoù en est la prise du métal, pourquoi il ne coule pas, son métal en fusion
Obus HE, à éclats (Shrapnel), perce-armure (AP), de mortier (Drop Mortar), fumigène, à fluideshellson détonateur, qu'il règle, et son traceur
Grande cartouchebig_cartridgesa poudre nitro, et si elle a pris l'eau
Conteneur de munitions pour autocanonautocannon_ammo_containerl'espacement de ses traceurs, qu'il règle

Big Cannons n'a pas de périphérique ComputerCraft à lui : ces méthodes lisent ce que montrent les Lunettes d'ingénieur et les écrans des blocs. Contre l'ordinateur, un bloc s'appelle par sa face ("top"...) ; sur un Câble de données (Mini-ordinateur et plus récents), il reçoit un nom comme shell@12,64,-30. Le plus simple est peripheral.find :

Brass
local culasse = peripheral.find("sliding_breech")
local obus = peripheral.find("shell")
print("culasse " .. culasse.state())
local det = obus.fuze()
if det then
  print(det.display, det.time)
end

Chaque méthode relit le bloc quand on l'appelle, et les nombres sont arrondis à 3 décimales. Quand quelque chose ne va pas, l'appel arrête le programme avec une erreur que pcall peut attraper :

erreurquand
sliding breech removed, shell removed...le bloc a été cassé ou remplacé (son type, avec des espaces) ; voir plus bas pour les culasses et les obus
peripheral is not loadedle chunk du bloc n'est pas chargé
this version of Create Big Cannons has no getFuzevotre version de Big Cannons n'a pas cette mesure (le nom à la fin est celui qui manque)
Create Big Cannons error: ...le bloc lui-même a échoué en répondant

Deux cas où le bloc a disparu sans être cassé : tant qu'un canon est assemblé sur son support, sa culasse fait partie du canon mobile et n'est plus un bloc, donc les méthodes de la culasse s'arrêtent sur sliding breech removed jusqu'au désassemblage ; et un obus poussé dans un canon n'est plus un bloc non plus (shell removed).

Aussi des blocs cinétiques. Les culasses, le chargeur et la perceuse tournent : le bloc enveloppé a donc en plus les méthodes de Blocs cinétiques de Create, comme speed(), la vitesse de son arbre en tr/min.

Aussi un réservoir ou un inventaire. Le conteneur de munitions pour autocanon est aussi un Inventaires. La perceuse, le moule et l'obus à fluide contiennent un fluide, mais ne montrent leur réservoir que sur certaines faces : la perceuse aux deux bouts de son tuyau, le moule sur le dessus, l'obus à fluide sur sa tête tant qu'il n'a pas de détonateur. Par ces faces, ils sont aussi un Réservoirs. La perceuse et le moule ont leur propre tanks(), qui lit leur réservoir quelle que soit la face qui touche l'ordinateur ou le câble ; il remplace celui du réservoir générique et renvoie la même table.

Méthodes
culasse.progress()L'ouverture de la culasse en fraction : 0.5 veut dire à moitié ouverte. Elle change à chaque tick tant que l'arbre tourne. Les deux culasses l'ont.
culasse.state()"closed" à 0, "open" à 1, "partial" entre les deux. Seule une culasse coulissante grande ouverte laisse passer un chargeur, et seule une culasse à vis complètement déverrouillée peut être écartée. Les deux culasses l'ont.
culasse.blocked()true quand une munition se trouve dans la culasse elle-même, ou que la tige d'un chargeur la traverse : la culasse ne peut alors pas se fermer, quoi que fasse son arbre (elle s'ouvre toujours). Culasse coulissante seulement : la culasse à vis n'a pas de blocked.
chargeur.extension()0 quand la tige est toute rentrée, jusqu'au nombre de ses barres quand elle est toute sortie, avec des fractions pendant qu'elle bouge.
chargeur.moving()true du moment où la tige part jusqu'à ce qu'elle soit reposée en blocs. Le chargeur part au tick qui suit le changement de son arbre : laissez-lui un instant avant de demander.
chargeur.problem()Le message que Create affiche pour cela, par exemple (en anglais) The Piston is missing some extension Poles ou There are too many extension Poles attached to this Piston... ; le jeu peut aussi le donner dans sa langue. Un chargeur qui a un problème ne bouge pas du tout.
perceuse.extension()0 quand la perceuse est toute rentrée, davantage à mesure que son foret avance dans le canon, avec des fractions pendant qu'il bouge.
perceuse.moving()true du moment où la perceuse part jusqu'à ce que sa tige soit reposée en blocs. Elle reste true pendant que la perceuse attend sur un problème : la tige est sortie mais immobile, et extension() ne change plus.
perceuse.boring()true pendant que le foret attaque un bloc de canon, au rythme que permet le tour ; false pendant qu'il traverse des blocs creux ou déjà percés, ou qu'il attend sur un problème.
perceuse.problem()Pourquoi la perceuse s'est arrêtée. Le problème reste jusqu'à ce que la vitesse de la perceuse change, même une fois sa cause disparue.
perceuse.tanks()L'eau de la perceuse, sous la forme de tank.tanks() : une entrée, fluid valant "minecraft:water" ou nil quand il est vide, amount et capacity (1000) en mB. Elle lit le réservoir quelle que soit la face de la perceuse qui touche l'ordinateur ou le câble.
moule.progress()0 pendant que le moule se remplit : la prise ne commence qu'une fois plein. Puis elle monte jusqu'à 1. À la fin, le moule devient un Moule de canon terminé dans le même tick, si bien qu'un programme lit rarement 1 : il reçoit plutôt cannon cast removed, que pcall transforme en signal de fin.
moule.problem()Présent quand le moule est plein d'un métal que Big Cannons ne sait pas couler dans la forme de l'une de ses couches, avec son message : Cannon cast at [x, y, z] does not have a valid recipe for fluid ... and shape .... Le moule ne prend alors pas : videz-le et versez un métal qui convient.
moule.tanks()Le métal dans le moule, sous la forme de tank.tanks() : une entrée, capacity étant le métal qu'il faut au moule entier. Le moule ne montre son réservoir que par le dessus, où l'on verse le métal ; ceci le lit quelle que soit la face qui touche l'ordinateur ou le câble.
obus.fuze()Le détonateur de l'obus. name est son identifiant d'objet ("createbigcannons:timed_fuze"), display son nom tel que le jeu l'affiche. time, en ticks, est présent pour un détonateur minuté ou retardé qui a un temps ; un détonateur jamais réglé n'en a pas, et un détonateur minuté sans temps éclate dès que l'obus vole : réglez-le donc. distance, en blocs, est présent pour un détonateur de proximité.
obus.set_fuze_time(ticks)Sur un détonateur minuté, le temps entre le tir et l'éclatement, gardé entre 1 et 495 ticks (presque 25 secondes) ; son écran avance par pas de 5, un programme règle n'importe quel entier. Sur un détonateur à impact retardé ou à inertie retardé, le délai entre l'impact et l'éclatement, de 1 à 100 ticks. Renvoie la valeur retenue. Le détonateur la reçoit à la fin du tick : fuze() dans le même tick montre encore l'ancien temps.
obus.set_fuze_distance(blocks)Sur un détonateur de proximité, à quelle distance d'un bloc (ou d'une entité) l'obus éclate, gardée entre 1 et 32 blocs. Renvoie la valeur retenue ; le détonateur la reçoit à la fin du tick. Tout autre détonateur, ou aucun, arrête le programme avec the shell has no proximity fuze.
obus.tracer()true quand un Pointeur (Tracer Tip) a été posé sur l'obus (sur n'importe quelle face) : son vol laisse alors une traînée lumineuse.
cartouche.charges()0 pour une cartouche vide, jusqu'à max_charges() pour une pleine : plus il y a de niveaux, plus le tir est fort.
cartouche.max_charges()4 avec les données par défaut du mod, qui le fixent.
cartouche.damp()Une cartouche que l'eau a atteinte est humide. Avec les réglages par défaut de Big Cannons, une poudre humide est plus faible, et elle ne part pas quand c'est la première poudre derrière l'obus. Hors de l'eau, elle sèche d'elle-même au bout d'un moment.
conteneur.tracer_spacing()1 fait de chaque coup un traceur, tant qu'il en reste ; 6 un coup sur six.
conteneur.set_tracer_spacing(rounds)Règle l'espacement comme l'écran du conteneur, tout de suite. La valeur est gardée entre 1 et 6 ; un nombre à décimales arrête le programme avec bad argument #1 to 'set_tracer_spacing' (number has no integer representation).

Culasses

Une culasse ferme l'arrière d'un gros canon. Son arbre l'ouvre et la ferme : tourné dans un sens il l'ouvre, dans l'autre il la ferme, d'autant plus vite que l'arbre tourne vite (à chaque tick, elle avance de tr/min / 512 du chemin : 0,8 seconde de fermée à ouverte à 32 tr/min). Sans rotation, elle reste où elle est.

  • La culasse coulissante (Sliding Breech) laisse passer les munitions une fois grande ouverte : un chargeur de canon pousse l'obus et ses charges à travers elle dans le fût. Elle ne se ferme pas tant qu'une munition ou la tige du chargeur y est encore.
  • La culasse à vis (Screw Breech, « Fermeture à vis » en jeu pour celle en acier) ne laisse rien passer. Une fois complètement déverrouillée ("open"), une machine animée l'écarte pour le chargement, puis la remet en place pour qu'on la ferme.

Un canon se charge quand il est en blocs, et s'assemble et tire culasse fermée. Avec la culasse ouverte en plus de la bouche, le support refuse de l'assembler (Cannon must have exactly one opening and exactly one closed end).

Une façon simple de piloter la culasse depuis un programme : un Inverseur de rotation sur son arbre, que la redstone de l'ordinateur inverse (rs.set). Chaque méthode ci-dessous dit quelles culasses l'ont.

#

culasse.progress()

→ number

L'ouverture de la culasse en fraction : 0.5 veut dire à moitié ouverte. Elle change à chaque tick tant que l'arbre tourne. Les deux culasses l'ont.

Renvoie
number
de combien la culasse est ouverte, de 0 (fermée) à 1 (grande ouverte)
Brass
local culasse = peripheral.find("sliding_breech")
print("ouverte à " .. math.floor(culasse.progress() * 100) .. " %")

Voir aussi breech.state()

#

culasse.state()

→ string

"closed" à 0, "open" à 1, "partial" entre les deux. Seule une culasse coulissante grande ouverte laisse passer un chargeur, et seule une culasse à vis complètement déverrouillée peut être écartée. Les deux culasses l'ont.

Renvoie
string
"closed", "partial" ou "open"
Brass
rs.set("left", false)   -- l'Inverseur de rotation sur l'arbre de la culasse : sans signal, il l'ouvre
while culasse.state() ~= "open" do
  sleep(0.1)
end
print("prête à charger")

Voir aussi breech.progress() breech.blocked()

#

culasse.blocked()

→ boolean

true quand une munition se trouve dans la culasse elle-même, ou que la tige d'un chargeur la traverse : la culasse ne peut alors pas se fermer, quoi que fasse son arbre (elle s'ouvre toujours). Culasse coulissante seulement : la culasse à vis n'a pas de blocked.

Renvoie
boolean
true quand quelque chose empêche la culasse de se fermer

Vérifiez-le avant de fermer, une fois la tige revenue :

Brass
if culasse.blocked() then
  print("fermeture impossible : il reste quelque chose dans la culasse")
else
  rs.set("left", true)  -- inverse l'arbre : la culasse se ferme
end

Voir aussi breech.state()

Chargeur de canon

Le chargeur de canon fonctionne comme un Piston mécanique. Des Barres d'extension de piston lui donnent sa portée, et une tête de bélier (Ram Head) à l'avant pousse les munitions alignées devant lui (un obus, puis ses charges) dans le canon, à travers la culasse ouverte ; une Tête de ver, elle, ressort les munitions d'un canon enrayé. Son arbre le pilote, dans un sens pour sortir, dans l'autre pour rentrer, à tr/min / 512 blocs par tick comme un piston : 1,25 bloc par seconde à 32 tr/min.

Au bout de ses barres, il s'arrête et repose sa tige en blocs, comme un piston, et reste ainsi jusqu'à ce que son arbre change de vitesse ou de sens. Un Inverseur de rotation séquencé le déplace d'un nombre exact de blocs, ce que sequenced_gearshift.move() fait depuis un programme.

Le canon doit être désassemblé (en blocs) pendant le chargement, et la tige retirée du canon avant de le réassembler : sinon le support refuse (Cannon block at [...] contains a cannon loader part).

#

chargeur.extension()

→ number

0 quand la tige est toute rentrée, jusqu'au nombre de ses barres quand elle est toute sortie, avec des fractions pendant qu'elle bouge.

Renvoie
number
de combien la tige est sortie, en blocs
Brass
local chargeur = peripheral.find("cannon_loader")
print("tige sortie de " .. chargeur.extension() .. " blocs")

Voir aussi cannon_loader.moving()

#

chargeur.moving()

→ boolean

true du moment où la tige part jusqu'à ce qu'elle soit reposée en blocs. Le chargeur part au tick qui suit le changement de son arbre : laissez-lui un instant avant de demander.

Renvoie
boolean
true pendant que la tige bouge
Brass
local inverseur = peripheral.find("sequenced_gearshift")
inverseur.move(4)   -- enfonce de 4 blocs
sleep(0.2)
while chargeur.moving() do
  sleep(0.1)
end
print("chargé")

Voir aussi cannon_loader.extension() cannon_loader.problem()

#

chargeur.problem()

→ string

Le message que Create affiche pour cela, par exemple (en anglais) The Piston is missing some extension Poles ou There are too many extension Poles attached to this Piston... ; le jeu peut aussi le donner dans sa langue. Un chargeur qui a un problème ne bouge pas du tout.

Renvoie
string
pourquoi le chargeur n'a pas pu partir, nil si son dernier départ s'est bien passé
Brass
local p = chargeur.problem()
if p then
  print("chargeur bloqué : " .. p)
end

Voir aussi cannon_loader.moving()

Perceuse de canon

La perceuse de canon alèse un bloc de canon coulé pour en faire un fût. Le bloc tourne sur un tour (un Roulement mécanique qui le tient, face à la perceuse), et la perceuse, qui sort une tige comme le chargeur avec un Foret de perceuse de canon au bout, s'y enfonce le long de son axe. Il lui faut deux choses :

  • De l'eau. Elle contient 1000 mB d'eau (rien d'autre), amenée par un tuyau à l'un des deux bouts de son tuyau. Le perçage la consomme, d'autant plus que le tour tourne vite.
  • De la vitesse. Son arbre doit tourner au moins aussi vite que le tour.

Quand l'une manque, la perceuse s'arrête là où elle est et note le problème. Elle ne repart pas d'elle-même une fois l'eau revenue ou le tour ralenti : seul un changement de sa propre vitesse la fait réessayer. Un Contrôleur de vitesse de rotation qui l'entraîne le fait depuis un programme (speed_controller.set_target_speed()).

#

perceuse.extension()

→ number

0 quand la perceuse est toute rentrée, davantage à mesure que son foret avance dans le canon, avec des fractions pendant qu'il bouge.

Renvoie
number
jusqu'où le foret est allé, en blocs
Brass
local perceuse = peripheral.find("cannon_drill")
print("foret à " .. perceuse.extension() .. " blocs")

Voir aussi cannon_drill.boring()

#

perceuse.moving()

→ boolean

true du moment où la perceuse part jusqu'à ce que sa tige soit reposée en blocs. Elle reste true pendant que la perceuse attend sur un problème : la tige est sortie mais immobile, et extension() ne change plus.

Renvoie
boolean
true tant que le foret est sorti en machine animée

Voir aussi cannon_drill.problem()

#

perceuse.boring()

→ boolean

true pendant que le foret attaque un bloc de canon, au rythme que permet le tour ; false pendant qu'il traverse des blocs creux ou déjà percés, ou qu'il attend sur un problème.

Renvoie
boolean
true pendant que la perceuse perce un bloc
Brass
print(perceuse.boring() and "perce" or "à l'arrêt")

Voir aussi cannon_drill.problem()

#

perceuse.problem()

→ string

Pourquoi la perceuse s'est arrêtée. Le problème reste jusqu'à ce que la vitesse de la perceuse change, même une fois sa cause disparue.

Renvoie
string
"dry_bore" (pas d'eau), "too_weak" (tour plus rapide que la perceuse), nil quand elle fonctionne

Ceci fait tourner une perceuse sans joueur : un Contrôleur de vitesse de rotation l'entraîne, et chaque fois qu'elle est à sec, le programme change sa vitesse de 1 tr/min, ce qui la fait réessayer (si l'eau manque encore, elle s'arrête de nouveau aussitôt).

Brass
local perceuse = peripheral.find("cannon_drill")
local ctrl = peripheral.find("speed_controller")  -- entraîne la perceuse, sous 256 tr/min
local base = ctrl.target_speed()
local pas = 0
while true do
  if perceuse.problem() == "dry_bore" then
    pas = 1 - pas                                  -- toute nouvelle vitesse relance la perceuse
    ctrl.set_target_speed(base + pas)
  end
  sleep(5)
end

Voir aussi cannon_drill.tanks()

#

perceuse.tanks()

→ table

L'eau de la perceuse, sous la forme de tank.tanks() : une entrée, fluid valant "minecraft:water" ou nil quand il est vide, amount et capacity (1000) en mB. Elle lit le réservoir quelle que soit la face de la perceuse qui touche l'ordinateur ou le câble.

Renvoie
table
une liste avec son réservoir d'eau, {fluid =, amount =, capacity =}
Brass
local eau = perceuse.tanks()[1]
print("eau " .. eau.amount .. " / " .. eau.capacity .. " mB")

Voir aussi tank.tanks()

Moule de canon

Un moule de canon est fait de Sable de moulage, monté couche par couche avec des moules de coulée, une couche par bloc du canon ; les couches empilées forment un seul moule, rempli de métal en fusion par le dessus. Chaque bloc du moule répond pour le moule entier : l'ordinateur peut toucher n'importe lequel.

Une fois plein, le métal prend : 2 minutes pour la fonte ou le bronze, 3 pour l'acier (les données du mod donnent son temps à chaque métal). Le moule devient alors un Moule de canon terminé, qui n'est pas un périphérique : dès lors, les méthodes arrêtent le programme avec cannon cast removed. Tant que le bloc du moule qui contient son métal manque, elles l'arrêtent avec cannon cast not ready.

#

moule.progress()

→ number

0 pendant que le moule se remplit : la prise ne commence qu'une fois plein. Puis elle monte jusqu'à 1. À la fin, le moule devient un Moule de canon terminé dans le même tick, si bien qu'un programme lit rarement 1 : il reçoit plutôt cannon cast removed, que pcall transforme en signal de fin.

Renvoie
number
où en est la prise du métal, de 0 à 1
Brass
local moule = peripheral.find("cannon_cast")
while true do
  local r = pcall(moule.progress)
  if not r.ok then
    print("moule terminé (ou cassé)")
    break
  end
  print(math.floor(r.value * 100) .. " % de prise")
  sleep(10)
end

Voir aussi cannon_cast.tanks()

#

moule.problem()

→ string

Présent quand le moule est plein d'un métal que Big Cannons ne sait pas couler dans la forme de l'une de ses couches, avec son message : Cannon cast at [x, y, z] does not have a valid recipe for fluid ... and shape .... Le moule ne prend alors pas : videz-le et versez un métal qui convient.

Renvoie
string
pourquoi le moule ne prend pas, nil quand tout va bien
Brass
local p = moule.problem()
if p then
  print(p)
end

Voir aussi cannon_cast.tanks()

#

moule.tanks()

→ table

Le métal dans le moule, sous la forme de tank.tanks() : une entrée, capacity étant le métal qu'il faut au moule entier. Le moule ne montre son réservoir que par le dessus, où l'on verse le métal ; ceci le lit quelle que soit la face qui touche l'ordinateur ou le câble.

Renvoie
table
une liste avec le métal en fusion du moule entier, {fluid =, amount =, capacity =}
Brass
local t = moule.tanks()[1]
print((t.fluid or "vide") .. " : " .. t.amount .. " / " .. t.capacity .. " mB")

Voir aussi tank.tanks() cannon_cast.progress()

Obus et détonateurs

Les obus HE, à éclats, perce-armure, de mortier, fumigènes et à fluide sont des périphériques de type shell tant qu'ils sont posés en blocs, par exemple alignés devant un chargeur de canon en attendant d'entrer. (Les projectiles qui ne prennent pas de détonateur, comme le projectile solide ou le projectile perce-armure, ne sont pas des périphériques.) Un détonateur (fuze) se place sur la tête de l'obus, ou sur sa base pour certains obus, à la main ou par un Déployeur, et décide quand l'obus éclate. Un programme le lit, et le règle comme le ferait l'écran du détonateur :

détonateurréglageméthodebornes
Détonateur minuté (Timed Fuze)temps entre le tir et l'éclatementset_fuze_time1 à 495 ticks
Détonateur à impact retardé, détonateur à inertie retardé (Delayed Inertia Fuze)délai entre l'impact et l'éclatementset_fuze_time1 à 100 ticks
Détonateur de proximitéà quelle distance de quelque chose il éclateset_fuze_distance1 à 32 blocs

Les temps sont en ticks : 20 ticks font une seconde. Quand le chargeur pousse l'obus dans le canon, le détonateur y entre avec lui, réglage compris, et l'obus n'est plus un bloc qu'un ordinateur peut atteindre : réglez le détonateur avant le chargement.

#

obus.fuze()

→ table

Le détonateur de l'obus. name est son identifiant d'objet ("createbigcannons:timed_fuze"), display son nom tel que le jeu l'affiche. time, en ticks, est présent pour un détonateur minuté ou retardé qui a un temps ; un détonateur jamais réglé n'en a pas, et un détonateur minuté sans temps éclate dès que l'obus vole : réglez-le donc. distance, en blocs, est présent pour un détonateur de proximité.

Renvoie
table
{name =, display =, time =, distance =}, nil quand l'obus n'a pas de détonateur
Brass
local obus = peripheral.find("shell")
local d = obus.fuze()
if d == nil then
  print("pas de détonateur")
elseif d.time then
  print(d.display .. " : " .. d.time / 20 .. " s")
else
  print(d.display)
end

Voir aussi shell.set_fuze_time() shell.set_fuze_distance()

#

obus.set_fuze_time(ticks)

→ number

Sur un détonateur minuté, le temps entre le tir et l'éclatement, gardé entre 1 et 495 ticks (presque 25 secondes) ; son écran avance par pas de 5, un programme règle n'importe quel entier. Sur un détonateur à impact retardé ou à inertie retardé, le délai entre l'impact et l'éclatement, de 1 à 100 ticks. Renvoie la valeur retenue. Le détonateur la reçoit à la fin du tick : fuze() dans le même tick montre encore l'ancien temps.

Paramètres
ticks number
le temps du détonateur, un nombre entier de ticks
Renvoie
number
le temps retenu

Tout autre détonateur, ou aucun, arrête le programme avec the shell has no timed or delayed fuze ; un nombre à décimales avec bad argument #1 to 'set_fuze_time' (number has no integer representation).

Un éclatement en l'air. Un détonateur minuté réglé un peu sous le temps de vol fait éclater l'obus au-dessus de sa cible. Le temps de vol dépend du canon, des charges et de l'angle : tirez quelques coups avec un long délai, notez combien de temps vole chacun, et laissez le programme calculer le détonateur pour n'importe quelle distance à partir de ces notes :

Brass
-- temps de vol notés pour ce canon et cette charge : {distance en blocs, ticks}
local VOL = {{100, 40}, {200, 84}, {300, 134}}

-- le temps de détonateur qui fait éclater l'obus `avance` ticks avant qu'il atteigne `distance`
local function detonateur_pour(distance, avance)
  for i = 2, #VOL do
    local a, b = VOL[i - 1], VOL[i]
    if distance <= b[1] then
      local t = a[2] + (b[2] - a[2]) * (distance - a[1]) / (b[1] - a[1])
      return math.max(1, math.min(495, math.floor(t - avance)))
    end
  end
  return 495
end

print(detonateur_pour(150, 4))
print(detonateur_pour(250, 4))
Écran
58
105

En jeu, obus.set_fuze_time(detonateur_pour(distance, 4)) le règle sur l'obus qui attend devant le chargeur.

Voir aussi shell.fuze()

#

obus.set_fuze_distance(blocks)

→ number

Sur un détonateur de proximité, à quelle distance d'un bloc (ou d'une entité) l'obus éclate, gardée entre 1 et 32 blocs. Renvoie la valeur retenue ; le détonateur la reçoit à la fin du tick. Tout autre détonateur, ou aucun, arrête le programme avec the shell has no proximity fuze.

Paramètres
blocks number
la distance, un nombre entier de blocs
Renvoie
number
la distance retenue
Brass
obus.set_fuze_distance(4)   -- éclate 4 blocs avant ce qu'il rencontre

Voir aussi shell.fuze()

#

obus.tracer()

→ boolean

true quand un Pointeur (Tracer Tip) a été posé sur l'obus (sur n'importe quelle face) : son vol laisse alors une traînée lumineuse.

Renvoie
boolean
true quand l'obus porte un traceur

Grande cartouche

Une grande cartouche est une charge propulsive d'un seul bloc pour gros canon. Elle se remplit de Poudre nitro sous forme d'objet, avant d'être posée (par fabrication ou avec un Déployeur), un niveau à la fois : sa puissance (« Power » dans son infobulle). Posée en bloc, alignée devant un chargeur par exemple, c'est un périphérique.

#

cartouche.charges()

→ number

0 pour une cartouche vide, jusqu'à max_charges() pour une pleine : plus il y a de niveaux, plus le tir est fort.

Renvoie
number
les niveaux de poudre nitro qu'elle contient
Brass
local cartouche = peripheral.find("big_cartridge")
print("puissance " .. cartouche.charges() .. " / " .. cartouche.max_charges())

Voir aussi big_cartridge.max_charges()

#

cartouche.max_charges()

→ number

4 avec les données par défaut du mod, qui le fixent.

Renvoie
number
le plus de niveaux qu'elle contient
#

cartouche.damp()

→ boolean

Une cartouche que l'eau a atteinte est humide. Avec les réglages par défaut de Big Cannons, une poudre humide est plus faible, et elle ne part pas quand c'est la première poudre derrière l'obus. Hors de l'eau, elle sèche d'elle-même au bout d'un moment.

Renvoie
boolean
true quand la cartouche a pris l'eau
Brass
if cartouche.damp() then
  print("poudre mouillée : laissez-la sécher")
end

Conteneur de munitions pour autocanon

Un conteneur de munitions pour autocanon contient des munitions d'autocanon et des munitions traçantes, et alimente un autocanon une fois posé sur sa culasse. Son écran règle la fréquence des traceurs : un tous les 1 à 6 coups. Posé en bloc, c'est un périphérique, et le réglage reste en lui quand on le ramasse pour le mettre sur une culasse. C'est aussi un Inventaires : l'emplacement 1 contient les munitions, l'emplacement 2 les traceurs (le conteneur créatif, Creative Autocannon Ammo Container, n'est pas un inventaire).

#

conteneur.tracer_spacing()

→ number

1 fait de chaque coup un traceur, tant qu'il en reste ; 6 un coup sur six.

Renvoie
number
un traceur tous les tant de coups, de 1 à 6
Brass
local conteneur = peripheral.find("autocannon_ammo_container")
print("un traceur tous les " .. conteneur.tracer_spacing() .. " coups")

Voir aussi autocannon_ammo_container.set_tracer_spacing()

#

conteneur.set_tracer_spacing(rounds)

→ number

Règle l'espacement comme l'écran du conteneur, tout de suite. La valeur est gardée entre 1 et 6 ; un nombre à décimales arrête le programme avec bad argument #1 to 'set_tracer_spacing' (number has no integer representation).

Paramètres
rounds number
un traceur tous les tant de coups, un nombre entier
Renvoie
number
l'espacement retenu, de 1 à 6
Brass
conteneur.set_tracer_spacing(3)

Voir aussi autocannon_ammo_container.tracer_spacing()

Un canon qui se recharge seul

Un programme complet pour un gros canon sur un support de canon, avec une culasse coulissante et un chargeur de canon derrière. Les munitions arrivent alignées devant la tête de bélier du chargeur, un obus d'abord (posé par un Déployeur, par exemple), ses charges derrière. À chaque coup, le programme ouvre la culasse, règle le détonateur minuté de l'obus, enfonce les munitions, retire la tige, ferme la culasse, puis assemble, vise et tire.

Le montage : un Inverseur de rotation sur l'arbre de la culasse, à gauche de l'ordinateur (sans signal il ouvre, avec un signal il ferme : échangez true et false si le vôtre tourne dans l'autre sens) ; un Inverseur de rotation séquencé sur l'arbre du chargeur ; le support, la culasse, le chargeur, l'inverseur séquencé et la place de l'obus sur le Câble de données de l'ordinateur.

Brass
local canon = peripheral.find("cannon_mount")
local chargeur = peripheral.find("cannon_loader")
local inverseur = peripheral.find("sequenced_gearshift")  -- entraîne le chargeur
local COURSE = 5   -- blocs que parcourt la tige pour enfoncer les munitions
local DELAI = 60   -- temps du détonateur : l'obus éclate 3 secondes après le tir

canon.disassemble()  -- la culasse n'est un bloc que tant que le canon n'est pas assemblé
sleep(1)
local culasse = peripheral.find("sliding_breech")
assert(culasse, "aucune culasse coulissante trouvée")

local function regler_culasse(etat)
  rs.set("left", etat == "closed")
  while culasse.state() ~= etat do
    sleep(0.1)
  end
end

local function bouger_tige(sens)
  inverseur.move(COURSE, sens)
  sleep(0.2)
  while inverseur.running() or chargeur.moving() do
    sleep(0.1)
  end
  assert(chargeur.problem() == nil, chargeur.problem())
end

while true do
  local obus = peripheral.find("shell")
  if obus == nil then
    print("en attente d'un obus devant le chargeur")
    sleep(5)
  else
    regler_culasse("open")
    local det = obus.fuze()
    if det and det.name == "createbigcannons:timed_fuze" then
      obus.set_fuze_time(DELAI)
    end
    bouger_tige(1)    -- l'obus et ses charges entrent
    bouger_tige(-1)   -- la tige se retire
    assert(not culasse.blocked(), "il reste quelque chose dans la culasse")
    regler_culasse("closed")
    canon.assemble()
    canon.aim(180, 30)
    while not canon.on_target() do
      sleep(0.1)
    end
    canon.fire()
    sleep(2)
    canon.disassemble()
    sleep(1)
  end
end

Le détonateur est écrit à la fin du tick, avant que le chargeur ne parte. Pour faire éclater les obus au-dessus d'une cible à une distance connue, remplacez DELAI par le detonateur_pour de shell.set_fuze_time(), et les angles de aim par ceux de la cible (voir Supports de canon).