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.
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érique | ce qu'il lit ou règle |
|---|---|---|
| Culasse coulissante (fonte, bronze, acier) | sliding_breech | de combien elle est ouverte, si quelque chose l'empêche de fermer |
| Culasse à vis (acier, nethersteel) | screw_breech | de combien elle est déverrouillée |
| Chargeur de canon | cannon_loader | de combien sa tige est sortie, si elle bouge, pourquoi elle n'a pas pu |
| Perceuse de canon | cannon_drill | jusqu'où elle a percé, pourquoi elle s'est arrêtée, son eau |
| Moule de canon | cannon_cast | où 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, à fluide | shell | son détonateur, qu'il règle, et son traceur |
| Grande cartouche | big_cartridge | sa poudre nitro, et si elle a pris l'eau |
| Conteneur de munitions pour autocanon | autocannon_ammo_container | l'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 :
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)
endChaque 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 :
| erreur | quand |
|---|---|
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 loaded | le chunk du bloc n'est pas chargé |
this version of Create Big Cannons has no getFuze | votre 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.
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()
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.
- number
- de combien la culasse est ouverte, de 0 (fermée) à 1 (grande ouverte)
local culasse = peripheral.find("sliding_breech")
print("ouverte à " .. math.floor(culasse.progress() * 100) .. " %")Voir aussi breech.state()
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.
- string
- "closed", "partial" ou "open"
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()
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.
- boolean
- true quand quelque chose empêche la culasse de se fermer
Vérifiez-le avant de fermer, une fois la tige revenue :
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
endVoir 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()
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.
- number
- de combien la tige est sortie, en blocs
local chargeur = peripheral.find("cannon_loader")
print("tige sortie de " .. chargeur.extension() .. " blocs")Voir aussi cannon_loader.moving()
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.
- boolean
- true pendant que la tige bouge
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()
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.
- string
- pourquoi le chargeur n'a pas pu partir, nil si son dernier départ s'est bien passé
local p = chargeur.problem()
if p then
print("chargeur bloqué : " .. p)
endVoir 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()
0 quand la perceuse est toute rentrée, davantage à mesure que son foret avance dans le canon, avec des fractions pendant qu'il bouge.
- number
- jusqu'où le foret est allé, en blocs
local perceuse = peripheral.find("cannon_drill")
print("foret à " .. perceuse.extension() .. " blocs")Voir aussi cannon_drill.boring()
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.
- boolean
- true tant que le foret est sorti en machine animée
Voir aussi cannon_drill.problem()
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.
- boolean
- true pendant que la perceuse perce un bloc
print(perceuse.boring() and "perce" or "à l'arrêt")Voir aussi cannon_drill.problem()
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.
- 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).
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)
endVoir aussi cannon_drill.tanks()
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.
- table
- une liste avec son réservoir d'eau,
{fluid =, amount =, capacity =}
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()
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.
- number
- où en est la prise du métal, de 0 à 1
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)
endVoir aussi cannon_cast.tanks()
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.
- string
- pourquoi le moule ne prend pas, nil quand tout va bien
local p = moule.problem()
if p then
print(p)
endVoir aussi cannon_cast.tanks()
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.
- table
- une liste avec le métal en fusion du moule entier,
{fluid =, amount =, capacity =}
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étonateur | réglage | méthode | bornes |
|---|---|---|---|
| Détonateur minuté (Timed Fuze) | temps entre le tir et l'éclatement | set_fuze_time | 1 à 495 ticks |
| Détonateur à impact retardé, détonateur à inertie retardé (Delayed Inertia Fuze) | délai entre l'impact et l'éclatement | set_fuze_time | 1 à 100 ticks |
| Détonateur de proximité | à quelle distance de quelque chose il éclate | set_fuze_distance | 1 à 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()
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é.
- table
{name =, display =, time =, distance =}, nil quand l'obus n'a pas de détonateur
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)
endVoir aussi shell.set_fuze_time() shell.set_fuze_distance()
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.
ticksnumber- le temps du détonateur, un nombre entier de ticks
- 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 :
-- 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))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)
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.
blocksnumber- la distance, un nombre entier de blocs
- number
- la distance retenue
obus.set_fuze_distance(4) -- éclate 4 blocs avant ce qu'il rencontreVoir aussi shell.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.
- 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()
0 pour une cartouche vide, jusqu'à max_charges() pour une pleine : plus il y a de niveaux, plus le tir est fort.
- number
- les niveaux de poudre nitro qu'elle contient
local cartouche = peripheral.find("big_cartridge")
print("puissance " .. cartouche.charges() .. " / " .. cartouche.max_charges())Voir aussi big_cartridge.max_charges()
cartouche.max_charges()
4 avec les données par défaut du mod, qui le fixent.
- number
- le plus de niveaux qu'elle contient
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.
- boolean
- true quand la cartouche a pris l'eau
if cartouche.damp() then
print("poudre mouillée : laissez-la sécher")
endConteneur 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()
1 fait de chaque coup un traceur, tant qu'il en reste ; 6 un coup sur six.
- number
- un traceur tous les tant de coups, de 1 à 6
local conteneur = peripheral.find("autocannon_ammo_container")
print("un traceur tous les " .. conteneur.tracer_spacing() .. " coups")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).
roundsnumber- un traceur tous les tant de coups, un nombre entier
- number
- l'espacement retenu, de 1 à 6
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.
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
endLe 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).