mirror of
https://github.com/MightyPirates/OpenComputers.git
synced 2025-09-08 23:06:58 -04:00
Merge branch 'master-MC1.7.10' of https://github.com/Pyeroh/OpenComputers into master-MC1.7.10
This commit is contained in:
Florian Nücke
commit
69e6fdbd38
@ -0,0 +1,13 @@
|
||||
# Point d'accès
|
||||
|
||||
|
||||
|
||||
*Ce bloc est déprécié et sera retiré dans une version future.* Transformez les en [relai](relay.md) pour éviter de les perdre.
|
||||
|
||||
Le point d'accès est la version sans-fil du [routeur](switch.md). Il peut être utilisé pour séparer des sous-réseaux pour que les machines qui les composent ne voient pas les [composants](../general/computer.md) des autres réseaux, tout en leur permettant d'envoyer des messages réseau aux machines d'autres réseaux.
|
||||
|
||||
En plus de ça, ce bloc peut faire office de répéteur : il peut renvoyer des messages filaires en tant que messages filaires à d'autres appareils, ou des messages sans-fil en tant que messages filaires ou sans-fil.
|
||||
|
||||
Les [routeurs](switch.md) et points d'accès ne gardent *pas* de trace des paquets qu'ils ont récemment relayé, donc évitez les boucles dans votre réseau ou vous pourriez recevoir le même paquet plusieurs fois. A cause de la taille limitée de la mémoire tampon des routeurs, une perte des paquets peut survenir si vous essayez d'envoyer des messages réseau trop fréquemment. Vous pouvez améliorer vos routeurs et points d'accès pour augmenter la vitesse à laquelle ils relaient les messages, ainsi que la taille interne de la file des messages.
|
||||
|
||||
Les paquets sont seulement renvoyés un certain nombre de fois, donc enchaîner un certain nombre de [routeurs](switch.md) ou de points d'accès n'est pas possible. Par défaut, un paquet sera renvoyé jusqu'à 5 fois.
|
||||
@ -0,0 +1,7 @@
|
||||
# Adaptateur
|
||||
|
||||
|
||||
|
||||
L'adaptateur permet aux [ordinateurs](../general/computer.md) d'interagir avec des blocs de Minecraft Vanilla ou d'autres mods. Les blocs supportés placés contre l'adaptateur s'afficheront en tant que composants sur les [ordinateurs](../general/computer.md) connectés à l'adaptateur.
|
||||
|
||||
En plus de ça, l'adaptateur fournit un emplacement pour certaines améliorations. Par exemple, l'[amélioration du contrôleur d'inventaire](../item/inventoryControllerUpgrade.md) permet aux ordinateurs de demander plus d'informations à un inventaire adjacent à l'adaptateur, comme le ferait un appareil sur lequel serait installé cette amélioration (comme un [robot](robot.md) ou un [drone](../item/drone.md)), et une [amélioration du contrôleur de réservoir](../item/tankControllerUpgrade.md) fournit des fonctionnalités similaires pour les tanks adjacents à l'adaptateur.
|
||||
@ -0,0 +1,13 @@
|
||||
# Assembleur électronique
|
||||
|
||||
|
||||
|
||||
L'assembleur est une table avancée qui peut être utilisée pour construire des appareils électroniques plus complexes, comme les [robots](robot.md), les [drones](../item/drone.md) et les [tablettes](../item/tablet.md). Il nécessite une grande quantité d'énergie pour assembler des appareils, il est donc recommandé de lui fournir suffisament d'énergie avec un [capaciteur](capacitor.md).
|
||||
|
||||
Pour contruire un appareil avec un assembleur, insérez la base de cet appreil. Pour les [robots](robot.md), c'est un [boîtier d'ordinateur](case1.md) de n'importe quel niveau; et pour les [tablettes](../item/tablet.md), un [boîtier de tablette](../item/tabletCase1.md). Comme dans tous les inventaires d'OpenComputers, chaque élément peut être inséré dans un emplacement spécifique; survoler un emplacement surligne les éléments de votre inventaire qui peut aller dans cet emplacement. Si vous avez NEI ouvert, filtré pour afficher les objets d'OpenComputers, les objets compatibles seront surlignés également dans NEI. Continuez à insérer les éléments que vous souhaitez que votre appareil contienne. Prenez un soin particulier à fournir un système d'exploitation, ou un moyen de l'installer plus tard (pour les robots vous pouvez installer un [lecteur de disque](diskDrive.md) pour insérer et éjecter des [disquettes](../item/floppy.md) plus tard, par exemple). Pour la plupart des appareils, leur [EEPROM](../item/eeprom.md) peut être changée plus tard, en les fabriquant eux-même avec une autre [EEPROM](../item/eeprom.md) pour l'insérer. L'[EEPROM](../item/eeprom.md) existante de l'appareil sera renvoyée dans votre inventaire.
|
||||
|
||||
Remarquez également que pour que les [robots](robot.md) aient un [écran](screen1.md), vous devrez leur installer un [écran (tier 1)](screen1.md), et pour permettre de saisir sur l'[écran](screen1.md), vous devrez installer un [clavier](keyboard.md). Pour les [tablettes](../item/tablet.md), l'[écran](screen1.md) est pré-installé dans le [boîtier de tablette](../item/tabletCase1.md), mais vous aurez besoin besoin d'installer un [clavier](keyboard.md) si vous voulez écrire sur la [tablette](../item/tablet.md).
|
||||
|
||||
Une fois que tout est en place, appuyez sur le bouton Démarrer et attendez que l'appareil soit assemblé et chargé. Il est important de se rappeler que vous *ne pouvez pas* modifier l'appareil une fois qu'il a été assemblé. Si vous avez oublié quelque chose ou fait une erreur, vous devrez désassembler l'appareil en utilisant le [désassembleur](disassembler.md), ce qui a une faible chance de casser des éléments dans le processus.
|
||||
|
||||
Une dernière note sur la complexité : le niveau d'un objet détermine la complexité qu'il nécessite, sachant que les objets de niveau 1 nécessitent 1 de complexité, ceux de niveau 2 ont besoin de 2 et ceux de niveau 3 ont besoin de 3. Les améliorations de conteneur sont l'exception, car leur complexité est deux fois le niveau du conteneur (ex: une [amélioration de conteneur](../item/upgradeContainer1.md) de niveau 2 nécessite 4 de complexité, et de même pour les [conteneurs de carte](../item/cardContainer1.md)).
|
||||
@ -0,0 +1,9 @@
|
||||
# Câble
|
||||
|
||||
|
||||
|
||||
Le câble à connecter des [ordinateurs](../general/computer.md) et des machines éloignés les uns des autres. Si vous avez un système compact où tous les composants sont en contact (directement ou indirectement, la plupart des blocs du mod se comportent également de la même manière que les câbles), vous n'aurez généralement pas besoin de câbles.
|
||||
|
||||
Les câbles peuvent être colorés en utilisant n'importe quel type de colorant. Des câbles colorés se connecteront uniquement à des câbles de la même couleur et des câbles gris clair - la couleur par défaut. Cela peut être utile pour faire passer des câbles de plusieurs sous-réseaux en parallèle, sans utiliser de *cover* MultiPart ou Microblocks.
|
||||
|
||||
Si nécessaire, les câbles peuvent être couverts en utilisant les *covers* de Forge MultiPart, ou celles d'Immibis Microblocks. Gardez en tête que les [impressions 3D](print.md) sont compatible avec Forge MultiPart, donc il est possible d'imprimer des *covers* personnalisées, si vous le voulez.
|
||||
@ -0,0 +1,9 @@
|
||||
# Capaciteur
|
||||
|
||||
|
||||
|
||||
Le capaciteur emmagasine de l'énergie qui sera utilisée par le réseau, en se comportant comme un tampon d'énergie au besoin. Contrairement à la conversion de l'énergie d'autres mods vers l'énergie interne à OpenComputers (en utilisant un [convertisseur énergétique](powerConverter.md) par exemple), le transfert d'énergie dans un sous-réseau est instantané. Posséder un tampon d'énergie interne sera utile pour des tâches qui nécessitent beaucoup d'énergie, comme l'[assemblage](assembler.md) et/ou la [charge](charger.md) d'appareils comme les [robots](robot.md) ou les [drones](../item/drone.md).
|
||||
|
||||
L'efficacité de stockage des capaciteurs augmente avec le nombre de capaciteurs en contact direct ou à promixité. Par exemple, 2 capaciteurs directement en contact auront une plus grande capacité de stockage que la somme de 2 capaciteurs séparés. Ce bonus de proximité s'applique aux capaciteurs jusqu'à 2 blocs de distance, et diminue au fur et à mesure que la distance entre les capaciteurs augmente.
|
||||
|
||||
Le capaciteur peut être connecté à un [distributeur énergétique](powerDistributor.md) pour fournir de l'énergie aux autres [ordinateurs](../general/computer.md) ou machines du réseau.
|
||||
@ -0,0 +1,37 @@
|
||||
# Boîtier d'ordinateur
|
||||
|
||||
|
||||
|
||||
Les boîtiers d'ordinateur existent en 3 niveaux différents, ce qui limite les composants qui peuvent y être insérés. Un niveau supplémentaire existe aussi, seulement pour le mode créatif. Les boîtiers d'ordinateur peuvent également être placés dans un [assembleur électronique](assembler.md) pour construire des [robots](robot.md).
|
||||
|
||||
Le chiffre romain affiché dans le coin d'un emplacement du boîtier indique le niveau maximum du composant qui peut y être inséré. Un emplacement de niveau 2 peut accepter un composant de niveau 1, par exemple.
|
||||
|
||||
Le boîtier de niveau 1 peut accueillir au maximum les composants suivants :
|
||||
- 2x cartes d'extension de niveau 1 (comme les [cartes graphiques](../item/graphicsCard1.md), les [cartes réseau](../item/lanCard.md), etc.)
|
||||
- 1x [processeur](../item/cpu1.md) de niveau 1
|
||||
- 2x [barettes de RAM](../item/ram1.md) de niveau 1
|
||||
- 1x [disque dur](../item/hdd1.md) de niveau 1
|
||||
|
||||
Le boîtier de niveau 2 peut accueillir au maximum les composants suivants :
|
||||
- 1x carte d'extension de niveau 2 (comme les [cartes graphiques](../item/graphicsCard1.md), les [cartes réseau](../item/lanCard.md), etc.)
|
||||
- 1x carte d'extension de niveau 1
|
||||
- 1x [processeur](../item/cpu2.md) de niveau 2
|
||||
- 2x [barettes de RAM](../item/ram3.md) de niveau 2
|
||||
- 1x [disque dur](../item/hdd1.md) de niveau 1
|
||||
- 1x [disque dur](../item/hdd2.md) de niveau 2
|
||||
|
||||
Le boîtier de niveau 3 peut accueillir au maximum les composants suivants :
|
||||
- 1x carte d'extension de niveau 3 (comme les [cartes graphiques](../item/graphicsCard1.md), les [cartes réseau](../item/lanCard.md), etc.)
|
||||
- 2x carte d'extension de niveau 2
|
||||
- 1x [processeur](../item/cpu3.md) de niveau 3
|
||||
- 2x [barettes de RAM](../item/ram5.md) de niveau 3
|
||||
- 1x [disque dur](../item/hdd2.md) de niveau 2
|
||||
- 1x [disque dur](../item/hdd3.md) de niveau 3
|
||||
- 1x [disquette](../item/floppy.md)
|
||||
|
||||
Le boîtier de niveau 4 (créatif) peut accueillir les composants suivants :
|
||||
- 3x carte d'extension de niveau 3 (comme les [cartes graphiques](../item/graphicsCard1.md), les [cartes réseau](../item/lanCard.md), etc.)
|
||||
- 1x [processeur](../item/cpu3.md) de niveau 3
|
||||
- 2x [barettes de RAM](../item/ram5.md) de niveau 3
|
||||
- 2x [disque dur](../item/hdd2.md) de niveau 3
|
||||
- 1x [disquette](../item/floppy.md)
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT case1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT case1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT case1.md
|
||||
@ -0,0 +1,7 @@
|
||||
# Bloc de Chamélium
|
||||
|
||||
|
||||
|
||||
Quelques morceaux de [chamélium](../item/chamelium.md) peuvent être combinés pour fournir un bloc monochrome à des fins décoratives. Les blocs de chamélium peuvent aussi être teintés avec n'importe laquelle des 16 couleurs de Minecraft.
|
||||
|
||||
Utiliser un bloc de chamélium comme texture pour les [impressions 3D](print.md) fournit une surface propre et blanche pour appliquer les teintes.
|
||||
@ -0,0 +1,9 @@
|
||||
# Chargeur
|
||||
|
||||
|
||||
|
||||
Le chargeur est utilisé pour charger des appareils comme les [robots](robot.md), les [drones](../item/drone.md) et les [tablettes](../item/tablet.md). Un chargeur doit être activé en lui appliquant un signal de redstone. La vitesse de charge est basée sur la force du signal de redstone appliqué, avec une force de 15 donnant une vitesse de charge de 100%.
|
||||
|
||||
Remarquez que cette logique peut être inversée en frappant le chargeur avec une [clé](../item/wrench.md).. En mode inversé, le chargeur charge par défaut à 100% de sa vitesse, en diminuant en vitesse de charge quand la force du signal de redstone augmente.
|
||||
|
||||
Quand une [tablette](../item/tablet.md) est placée dans le chargeur, le premier [disque dur](../item/hdd1.md) est également aux [ordinateurs](../general/computer.md) connectés au chargeur, de la même manière que les [disquettes](../item/floppy.md) le sont avec un [lecteur de disque](diskDrive.md). Cela permet de transférer des données entre l'[ordinateur](../general/computer.md) et la [tablette](../item/tablet.md).
|
||||
@ -0,0 +1,7 @@
|
||||
# Désassembleur
|
||||
|
||||
|
||||
|
||||
Le désassembleur peut être utilisé pour déconstruire la plupart des objets d'OpenComputers en leurs éléments d'origine. C'est particulièrement utile pour récupérer des matériaux à partir d'anciens éléments qui ne sont plus utiles, ou pour déconstruire des appareils qui ne sont plus nécessaire ou qui ont été mal montés (ex : un [robot](robot.md) sans [système d'exploitation](../general/openOS.md)).
|
||||
|
||||
Désassembler des objets prend un long moment, et de l'énergie. Il y a également une faible chance de perdre un composant (qui est appliqué au composant complet à désassembler).
|
||||
@ -0,0 +1,9 @@
|
||||
# Lecteur de disquettes
|
||||
|
||||
|
||||
|
||||
Le lecteur de disquettes peut être utilisé pour lire des [disquettes](../item/floppy.md) en se servant d'un [ordinateur](../general/computer.md) connecté au lecteur de disquette. C'est très utile pour démarrer, car les niveaux les plus inférieurs de [boîtier d'ordinateur](case1.md) n'ont pas d'emplacement pour disquettes pré-construit, et vous aurez besoin d'un système d'exploitation pour démarrer l'[ordinateur](../general/computer.md). Un disque d'[OpenOS](../general/openOS.md) peut être fabriqué en utilisant une [disquette](../item/floppy.md) vierge et un [manuel](../item/manual.md).
|
||||
|
||||
Il peut également être installé sur les [robots](robot.md) pour pouvoir y insérer des [disquettes](../item/floppy.md). Cela peut être très utile car le seul autre moyen de transférer des données vers et depuis un robot est d'utiliser le réseau - par exemple en utilisant une [carte réseau](../item/lanCard.md).
|
||||
|
||||
Les [disquettes](../item/floppy.md) peuvent être insérées et retirées dans ouvrir l'interface du lecteur de disquette en faisant un clic-droit en étant accroupi avec la [disquette](../item/floppy.md) en main.
|
||||
@ -0,0 +1,7 @@
|
||||
# Géolyseur
|
||||
|
||||
|
||||
|
||||
Le géolyseur peut être utilisé par les [ordinateurs](../general/computer.md) pour scanner le terrain autour du géolyseur par la dureté approximative des blocs. Cela peut être utile pour générer des cartes du terrain à afficher sur un [projecteur d'hologramme](hologram1.md) ou pour détecter des blocs potentiellement précieux (les minerais sont généralement plus durs que la terre et la pierre). Les résultats du scan du géolyseur ont une certaine quantité de bruit ajoutée; en théorie, de nombreux scans peuvent être effectués pour obtenir une meilleure lecture du niveau de dureté d'un bloc.
|
||||
|
||||
Le géolyseur peut également être installé sur les [robots](robot.md) et les [tablettes](../item/tablet.md) en tant qu'amélioration pour leur permettre de scanner les environs. Cependant, effectuer un scan consommera de l'énergie, donc utiliser cette fonction excessivement épuisera les batteries de l'appareil.
|
||||
@ -0,0 +1,7 @@
|
||||
# Projecteur d'hologramme
|
||||
|
||||
|
||||
|
||||
Le projecteur d'hologramme est un afficheur volumétrique, c'est à dire qu'il fournit un tableau de voxels en trois dimensions qui peuvent être individuellement par un [ordinateur](../general/computer.md) auquel il serait connecté. Le deuxième niveau de projecteur, même s'il a la même résolution que le projecteur de niveau 1, gère l'affichage de chaque voxel avec trois couleurs définissable par l'utilisateur.
|
||||
|
||||
Les hologrammes peuvent être pivotés sur leur axe vertical en les frappant sur le haut ou le bas du projecteur avec une [clé](../item/wrench.md). Cela peut économiser beaucoup d'efforts, pour que la sortie ne soit pas transformée côté programme. Les hologrammes peuvent également être redimensionnés à volonté.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT hologram1.md
|
||||
@ -0,0 +1,48 @@
|
||||
# Blocs
|
||||
|
||||
Cet index liste tous les blocs documentés d'OpenComputers. Si vous cherchez un objet, allez plutôt voir l'[index des objets](../item/index.md).
|
||||
|
||||
Gardez en tête que certains d'entre eux ne sont pas disponibles, en fonction de l'ensemble de recettes sélectionné.
|
||||
|
||||
## Ordinateurs
|
||||
* [Boîtier d'ordinateur](case1.md)
|
||||
* [Micro-contrôleur](microcontroller.md)
|
||||
* [Robot](robot.md)
|
||||
* [Support de serveur](serverRack.md)
|
||||
|
||||
## Composants
|
||||
|
||||
### Entrée / Sortie
|
||||
* [Projecteur d'hologramme](hologram1.md)
|
||||
* [Clavier](keyboard.md)
|
||||
* [Ecran](screen1.md)
|
||||
|
||||
### Stockage
|
||||
* [Lecteur de disquette](diskDrive.md)
|
||||
* [RAID](raid.md)
|
||||
|
||||
### Extensions
|
||||
* [Adaptateur](adapter.md)
|
||||
* [Géoliseur](geolyzer.md)
|
||||
* [Détecteur de mouvement](motionSensor.md)
|
||||
* [Redstone E/S](redstone.md)
|
||||
* [Transposeur](transposer.md)
|
||||
* [Point de passage](waypoint.md)
|
||||
|
||||
## Assemblage / Impression
|
||||
* [Impression 3D](print.md)
|
||||
* [Imprimante 3D](printer.md)
|
||||
* [Assembleur électronique](assembler.md)
|
||||
* [Bloc de Chamélium](chameliumBlock.md)
|
||||
* [Désassembleur](disassembler.md)
|
||||
|
||||
## Réseau
|
||||
* [Câble](cable.md)
|
||||
* [Répartiteur réseau](netSplitter.md)
|
||||
* [Relai](relay.md)
|
||||
|
||||
## Gestion de l'énergie
|
||||
* [Capaciteur](capacitor.md)
|
||||
* [Chargeur](charger.md)
|
||||
* [Convertisseur énergétique](powerConverter.md)
|
||||
* [Distributeur énergétique](powerDistributor.md)
|
||||
@ -0,0 +1,7 @@
|
||||
# Clavier
|
||||
|
||||
|
||||
|
||||
Un clavier est requis pour saisir du texte sur l'[écran](screen1.md), qu'ils existent physiquement dans le monde ou intégrés à un appareil comme un [robot](robot.md) ou une [tablette](../item/tablet.md).
|
||||
|
||||
Pour qu'un clavier fonctionne avec un [écran](screen1.md) dans le monde, il doit être placé à côté de l'[écran](screen1.md), orienté vers cet [écran](screen1.md), ou placé directement sur l'[écran](screen1.md) (au dessus ou sur l'une de ses faces). Vous pouvez savoir si un clavier est "connecté" à un [écran](screen1.md) si l'interface de l'[écran](screen1.md) s'ouvre en utilisant le clavier.
|
||||
@ -0,0 +1,7 @@
|
||||
# Micro-contrôleur
|
||||
|
||||
|
||||
|
||||
Les micro-contrôleurs sont construits en utilisant un [boîtier pour micro-contrôleur](../item/microcontrollerCase1.md) dans l'[assembleur](assembler.md). Ils ont moins de fonctionnalités qu'un [ordinateur](../general/computer.md), mais coûtent moins cher à construire. En particulier, ils *ne peuvent pas* interagir avec des composants externes.
|
||||
|
||||
Les micro-contrôleurs peuvent intégrer de nombreux composants, comme des [processeurs](../item/cpu1.md), de la [mémoire (RAM)](../item/ram1.md), et des cartes d'extension. Les micro-contrôleurs sont incapables de contenir un [disque dur](../item/hdd1.md), mais ont un emplacement pour une [EEPROM](../item/eeprom.md), qui peut être programmmée pour des tâches très spécifiques. Ils ont un avantage sur les boîtiers d'ordinateur, car ils peuvent également utiliser certaines améliorations, comme l'[amélioration de piston](../item/pistonUpgrade.md).
|
||||
@ -0,0 +1,7 @@
|
||||
# Détecteur de mouvement
|
||||
|
||||
|
||||
|
||||
Le détecteur de mouvement permet aux [ordinateurs](../general/computer.md) de détecter le mouvement des entités vivantes. Si une entité se déplace plus vite qu'un seuil défini, un signal sera injecté dans les [ordinateurs](../general/computer.md) connectés au détecteur de mouvement. Le seuil peut être configuré en utilisant l'API des composants que le détecteur de mouvement expose aux ordinateurs connectés.
|
||||
|
||||
Le mouvement est seulement détecté s'il survient dans un rayon de huit blocs autour du détecteur de mouvement, et s'il y a une ligne de mire directe entre le bloc et l'entité qui a bougé.
|
||||
@ -0,0 +1,7 @@
|
||||
# Répartiteur réseau
|
||||
|
||||
|
||||
|
||||
Le répartiteur réseau est un appareil qui permet de contrôler la connectivité entre des sous-réseaux. A la différence du [relai](relay.md) ou du [convertisseur énergétique](powerConverter.md), il connecte directement entre eux des sous-réseaux voisins, c'est à dire qu'il est possible d'accéder aux composants des sous-réseaux. La connectivité de chaque face peut être activée en utilisant une clé (ex: le [crisseur](../item/wrench.md)). Quand un signal de redstone est appliqué au répartiteur réseau, la connectivité de toutes les faces est inversée.
|
||||
|
||||
Ce bloc peut donc être utilisé pour activer la connectivité de certaines parties d'un réseau. Utilisez un [bloc d'E/S redstone](redstone.md) ou des [cartes de redstone](../item/redstoneCard1.md) pour automatiser le répartiteur réseau.
|
||||
@ -0,0 +1,5 @@
|
||||
# Convertisseur énergétique
|
||||
|
||||
|
||||
|
||||
Le convertisseur énergétique est la manière la plus rapide de convertir de l'énergie provenant d'autres mods en énergie interne à OpenComputers. Si vous utilisez un seul ordinateur, vous n'aurez probablement pas besoin de convertisseur. Si vous avez un grand groupe de capaciteurs dont vous utilisez l'énergie de temps en temps, vous n'en aurez sûrement pas besoin non plus. Cependant, si vous souhaitez alimenter directement un [assembleur électronique](assembler.md) ou un [chargeur](charger.md), c'est généralement une bonne idée d'utiliser un convertiseeur au lieu de les connecter directement à une source externe d'énergie.
|
||||
@ -0,0 +1,5 @@
|
||||
# Distributeur énergétique
|
||||
|
||||
|
||||
|
||||
Le distributeur énergétique distribue l'énergie d'un espace de stockage partagé (comme un [capaciteur](capacitor.md)), permettant à de nombreux sous-réseaux de partager leur énergie sans que leurs composants soient exposés aux ordinateurs des autres sous-réseaux. Il fonctionne en répartissant équitablement l'énergie dans tous les sous-réseaux auquel il est connecté, de façon à ce que la quantité *relative* d'énergie est la même dans chacun.
|
||||
@ -0,0 +1,11 @@
|
||||
# Impression 3D
|
||||
|
||||
|
||||
|
||||
Une impression 3D est créée en utilisant une [imprimante 3D](printer.md). Ces impressions sont prévues initialement dans un but décoratif, mais elles peuvent également être créées de manière à ce qu'elles émettent ou réagissent à des signaux de redstone, permettant d'agrandir un peu leur champ de fonctionnalité.
|
||||
|
||||
Les impressions 3D peuvent être recyclées en les remettant dans une [imprimante 3D](printer.md). Cela permettra de réutiliser une partie du [chamélium](../item/chamelium.md) qui avait été consommé pour les imprimer. La couleur utilisée pour imprimer le modèle ne sera pas recyclée.
|
||||
|
||||
En maintenant la touche pour l'affichage étendu des infobulles d'OpenComputers (`Maj` par défaut), l'état actuel d'une impression sera affiché, s'il existe.
|
||||
|
||||
Les blocs imprimés sont également compatible avec Forge MultiPart. S'il est présent, plusieurs impressions peuvent être placées dans l'espace d'un seul bloc, sauf si elles se chevauchent, et le nombre total de forme dans l'espace du bloc ne dépasse pas la limite pour un modèle. De part la nature de Forge MultiPart, les impressions peuvent aussi être placées dans le même bloc qu'un autre bloc compatible avec Forge MultiPart, comme les torches, les leviers, les câbles ou les fils d'alliage rouge de Project:Red, par exemple.
|
||||
@ -0,0 +1,18 @@
|
||||
# Imprimante 3D
|
||||
|
||||
|
||||
|
||||
Les imprimantes 3D vous permettent d'imprimer n'importe quel bloc de n'importe forme, avec n'importe quelle texture. Pour démarrer avec les imprimantes 3D, vous devrez placer un bloc d'imprimante 3D à côté d'un ordinateur. Cela vous donnera accès à l'API de composant `printer3d`, ce qui permet de paramétrer et d'imprimer des [modèles](print.md) en utilisant les fonction fournies.
|
||||
|
||||
Une manière plus simple d'installer une imprimante 3D est d'utiliser le gestionnaire de paquets Open Programs (OPPM). Une fois installé (`oppm install oppm`), assurez vous d'avoir une [carte internet](../item/internetCard.md) dans votre [ordinateur](../general/computer.md) and lancez la commande suivante :
|
||||
`oppm install print3d-examples`
|
||||
|
||||
Vous pouvez trouver des exemples dans `/usr/share/models/` sous forme de fichiers .3dm. Jetez un oeil dans ces fichiers d'exemple pour voir les options disponibles, en particulier le fichier `example.3dm`. Par ailleurs, vous pouvez télécharger les programmes `print3d` et `print3d-examples` depuis [OpenPrograms](https://github.com/OpenPrograms) en utilisant `wget` et une [carte internet](../item/internetCard.md).
|
||||
|
||||
Afin d'imprimer les modèles, une imprimante 3D doit être configurée par un [ordinateur](../general/computer.md). S'il est mis en mode sans-arrêt, l'ordinateur ne sera plus requis par la suite. Vous devrez également lui fournir une [cartouche d'encre](../item/inkCartridge.md) et un peu de [chamélium](../item/chamelium.md) pour les matières premières. La quantité de chamélium utilisée dépend du volume de l'impression 3D, tandis que la quantité d'encre utilisée dépend de la surface de l'objet imprimé.
|
||||
|
||||
Pour imprimer un objet, utilisez la commande suivante :
|
||||
`print3d /path/to/file.3dm`
|
||||
en fournissant le chemin vers le fichier .3dm.
|
||||
|
||||
Vous pourrez trouver la documentation relative à la création de vos propres modèles dans `/usr/share/models/example.3dm`.
|
||||
@ -0,0 +1,11 @@
|
||||
# Raid
|
||||
|
||||
|
||||
|
||||
Le bloc de RAID peut accueillir 3 [disques dur](../item/hdd1.md) qui seront combinés en un seul système de fichiers. Ce système de fichiers combinés a la taille de la somme des capacités des [disques dur](../item/hdd1.md) individuels, et est disponible pour tous les [ordinateurs](../general/computer.md) connectés au RAID.
|
||||
|
||||
Le RAID fonctionne uniquement (et se présente en tant que système de fichiers) quand 3 [disques dur](../item/hdd1.md) sont présents. Les [disques dur](../item/hdd1.md) peuvent avec chacun une taille différente.
|
||||
|
||||
Faites attention, car l'ajout d'un [disque dur](../item/hdd1.md) au bloc de RAID effacera son contenu. Retirer un [disque dur](../item/hdd1.md) du RAID effacera le contenu complet du RAID. Remettre le disque en place *ne restaurera pas* les anciens fichiers; le RAID sera ré-initialisé en tant que système de fichiers vierge.
|
||||
|
||||
Casser un bloc de RAID gardera son contenu, dons il peut être déplacé en tout sécurité sans risque de perte de données.
|
||||
@ -0,0 +1,9 @@
|
||||
# Redstone E/S
|
||||
|
||||
|
||||
|
||||
Le bloc d'E/S de redstone peut être utilisé pour lire et émettre des signaux de redstone à distance. Il se comporte comme un hybride des [cartes de redstone](../item/redstoneCard1.md) de niveau 1 et 2 : il peut aussi bien lire et émettre des signaux analogiques que des signaux empaquetés (bundle), mais il ne peut pas lire ou émettre de signaux redstone sans-fil.
|
||||
|
||||
En indiquant un côté aux méthodes du composant exposé par ce bloc, les directions sont les points cardinaux, c'est à dire qu'il est recommandé d'utiliser `sides.north`, `sides.east`, etc.
|
||||
|
||||
De même que les [cartes de redstone](../item/redstoneCard1.md), ce bloc injecte un signal dans les [ordinateurs](../general/computer.md) connectés quand l'état du signal de redstone change - autant pour les signaux analogiques qu'empaquetés (bundle). Ce bloc peut également être configuré pour démarrer des [ordinateurs](../general/computer.md) connectés quand une certaine puissance de signal est dépassée, ce qui permet de démarrer automatiquement des [ordinateurs](../general/computer.md).
|
||||
@ -0,0 +1,13 @@
|
||||
# Relai
|
||||
|
||||
|
||||
|
||||
Le relai peut être utilisé pour permettre à différents sous-réseaux de s'envoyer des messages réseau entre eux, sans exposer leurs composants aux [ordinateurs](../general/computer.md) des autres réseaux. Maintenir l'état "local" d'un composant est généralement une bonne idée, pour éviter aux [ordinateurs](../general/computer.md) d'utiliser le mauvais [écran](screen1.md) ou pour éviter qu'une surcharge de composants survienne (ce qui provoque le crash de l'[ordinateur](../general/computer.md) et l'empêche de démarrer).
|
||||
|
||||
Le relai peut être amélioré en insérant une [carte de réseau sans-fil](../item/wlanCard.md) pour relayer aussi des messages sans-fil. Les messages sans-fil peuvent être reçus et relayés par d'autres relais avec une carte de réseau sans-fil, ou par des ordinateurs équipés d'une carte réseau sans-fil.
|
||||
|
||||
Par ailleurs, le relai peut être amélioré en utilisé des [cartes liées](../item/linkedCard.md). Dans ce cas, il transmettra aussi les messages à travers le tunnel de la carte liée; ceci aura le coût habituel, donc assurez vous que le relai a suffisamment d'énergie.
|
||||
|
||||
Les relais *ne gardent pas* de trace des paquets qu'ils ont transmis récemment, donc évitez les boucles dans votre réseau, ou vous pourriez recevoir le même paquet plusieurs fois. Envoyer des messages trop souvent causera la perte de paquets, à cause de la taille limitée du tampon des relais.
|
||||
|
||||
Les paquets sont seulement renvoyés un certain nombre de fois, donc enchaîner un certain nombre de relais n'est pas possible. Par défaut, un paquet sera renvoyé jusqu'à 5 fois.
|
||||
@ -0,0 +1,9 @@
|
||||
# Robot
|
||||
|
||||
|
||||
|
||||
Contrairement aux [ordinateurs](../general/computer.md), les robots peuvent se déplacer et interagir avec le monde un peu comme un joueur. Ils *ne peuvent pas* interagir avec des composants externes, cependant ! Si vous avez besoin de communiquer avec un [ordinateur](../general/computer.md) ou d'autres robots, utilisez une [carte réseau sans-fil](../item/wlanCard.md), ou créez une sorte de protocle de bas niveau en utilisant les signaux de redstone via une [carte de redstone](../item/redstoneCard1.md), par exemple.
|
||||
|
||||
Les robots sont construits en plaçant un [boîtier d'ordinateur](case1.md) de n'importe quel niveau dans un [assembleur](assembler.md). Des [boîtiers](case1.md) de plus haut niveau permettent de construire des robots plus complexes, grâce à leur capacité à contenir un [processeur](../item/cpu1.md) plus puissant. La complexité du robot (affichée dans l'[assembleur](assembler.md)) est déterminée par le niveau des composants et améliorations placés dans les emplacements du robot; des composants de plus haut niveau augmenteront d'avantage la complexité qu'un composant de plus bas niveau. Si la complexité du robot est trop élevée, l'[assembleur](assembler.md) ne construira pas le robot.
|
||||
|
||||
De nombreuses améliorations peuvent être placées dans les robots pour augmenter les fonctionnalités. Cela inclut les amélioration d'[inventaire](../item/inventoryUpgrade.md) et de [contrôle d'inventaire](../item/inventoryControllerUpgrade.md), de [réservoir](../item/tankUpgrade.md), de [navigation](../item/navigationUpgrade.md), entre autres. Les conteneurs d'[amélioration](../item/upgradeContainer1.md) et de [carte](../item/cardContainer1.md) et de [carte](../item/cardContainer1.md) peuvent être placés dans le robot pour insérer et retirer des composants et des améliorations à la volée. Un [lecteur de disquettes](diskDrive.md) peut également être placé dans le robot pour permettre l'insertion de [disquettes](../item/floppy.md), ce qui vous permettra d'installer [OpenOS](../general/openOS.md) sur le robot (une alternative est d'installer [OpenOS](../general/openOS.md) sur un [disque dur](../item/hdd1.md) vierge en utilisant un [ordinateur](../general/computer.md), et d'utiliser le [disque dur](../item/hdd1.md) pré-installé comme un composant dans l'assembleur de robot).
|
||||
@ -0,0 +1,18 @@
|
||||
# Ecrans
|
||||
|
||||
|
||||
|
||||
Un écran est utilisé en combinaison avec une [carte graphique](../item/graphicsCard1.md), pour permettre aux [ordinateurs](../general/computer.md) d'afficher du texte. Les différents niveaux d'écrans ont différentes capacités, comme le support de différentes résolutions et couleurs. La qualité des écrans va d'une faible résolution en affichage monochrome à une haute résolution en 256 couleurs.
|
||||
|
||||
La résolution disponible et la profondeur de couleurs dépend du composant de plus bas niveau. Si vous utilisez une [carte graphique (niveau 1)](../item/graphicsCard1.md) avec un [écran (niveau 3)](screen3.md), seules les couleurs et la résolutions de niveau 1 seront disponibles. Cependant, en utilisant une [carte graphique](../item/graphicsCard1.md) de niveau 3 avec un écran de niveau 1, même si la résolution et la profondeur de couleur seront limitées au niveau 1, les opérations de la [carte graphique](../item/graphicsCard1.md) seront plus rapides qu'en utilisant une [carte graphique](../item/graphicsCard1.md) de niveau 1.
|
||||
|
||||
Les écrans peuvent être placés les uns contre les autres pour former un écran multi-bloc, tant qu'ils sont dans la même direction. S'ils sont placés vers le haut ou le bas ils doivent également être tournés dans le même sens. Leur orientation est indiquée par une flèche dans la barre d'inventaire en tenant l'écran en main.
|
||||
|
||||
La taille d'un écran n'a pas d'impact sur la résolution disponible, seulement son niveau. Pour gérer la manière dont les écrans se connectent entr eux, il est possible de les colorer avec n'importe quel colorant. Faites simplement un clic-droit sur l'écran avec un colorant en main. Le colorant ne sera pas consommé, mais les écrans ne garderont pas leur couleur une fois détruits. Des écrans de différente couleur ne se connecteront pas. Des écrans de différents niveaux ne connecteront jamais, même s'ils sont de la même couleur.
|
||||
|
||||
Les écrans de niveau 2 et 3 supportent également les entrées de la souris. Il est possible de cliquer soit dans l'interface de l'écran (qui peut seulement être ouvert si un [clavier](keyboard.md) est connecté à l'écran), soit en s'accroupissant pour cliquer dessus (avec la main vide dans le doute). Le fait de s'accroupir est optionnel si l'écran n'a pas de [clavier](keyboard.md). Remarquez qu'il est possible de contrôler l'ouverture de l'interface - ou en tout cas son activation - par l'API du composant exposée aux [ordinateurs](../general/computer.md). Les écrans de niveau 3 permettent une détection plus précise de l'endroit touché, si ça a été activé dans leur composant. Cela permet de détecter si la partie haute ou basse d'un caractère a été cliqué, par exemple, ce qui peut être utile si vous vous servez de caractères spéciaux en Unicode pour simuler de meilleures résolutions.
|
||||
|
||||
Les résolutions et profondeurs de couleur des écrans sont les suivantes :
|
||||
- Tier 1: 50x16, couleur sur 1-bit
|
||||
- Tier 2: 80x25, couleur sur 4-bit
|
||||
- Tier 3: 160x50, couleur sur 8-bit
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT screen1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT screen1.md
|
||||
@ -0,0 +1,9 @@
|
||||
# Support de serveur
|
||||
|
||||
|
||||
|
||||
Un support de serveur peut contenir jusqu'à 4 [serveurs](../item/server1.md). Un [serveur](../item/server1.md) est un [ordinateur](../general/computer.md) de plus haut niveau, qui peut seulement être lancé dans un support de serveur. Les [serveurs](../item/server1.md) peuvent être contrôlés à distance avec un [terminal à distance](../item/terminal.md). Le nombre de [terminaux à distance](../item/terminal.md) qui peuvent être connectés à un seul [serveur](../item/server1.md) à la fois dépend du niveau du [serveur](../item/server1.md). La distance jusqu'à laquelle le [terminal à distance](../item/terminal.md) fonctionne peut être configurée dans l'interface du support. De plus grandes valeurs nécessitent plus d'énergie.
|
||||
|
||||
Chaque [serveur](../item/server1.md) d'un support de serveur peut seulement communiquer avec un côté du support de serveur à la fois - ou aucun côté. Le côté auquel chaque [serveur](../item/server1.md) est connecté peut être configuré dans l'interface du support de serveur. Attention, les côtés dépendent du "point de vue" du support de serveur, par exemple si vous êtes en face de l'avant du support de serveur, `sides.right` sera à votre droite et inversement.
|
||||
|
||||
Les supports de serveur font office de [relai](relay.md) et de [distributeur énergétique](powerDistributor.md). Le mode routeur du support de serveur peut être configuré dans son interface, avec deux options : soit interne, soit externe. En mode externe, le support de serveur se comportera comme un [relai](relay.md) normal. En mode interne, les messages seront seulement transmis aux [serveurs](../item/server1.md) du support, et ne seront pas relayés automatiquement aux autres faces du support. Les [serveurs](../item/server1.md) seront toujours capables de s'envoyer des messages entre eux. Cela permet d'utiliser les supports de serveur comme des [relais](relay.md) évolués pouvant effectuer des filtres et des opérations de cartographie, par exemple.
|
||||
@ -0,0 +1,13 @@
|
||||
# Routeur
|
||||
|
||||
.](oredict:oc:switch)
|
||||
|
||||
*Ce bloc est déprécié et sera retiré dans une version future.* Transformez les en [relai](relay.md) pour éviter de les perdre.
|
||||
|
||||
Le routeur peut être utilisé pour permettre à différents sous-réseaux de s'envoyer des messages réseau entre eux, sans exposer leurs composants aux [ordinateurs](../general/computer.md) des autres réseaux. Maintenir l'état "local" d'un composant est généralement une bonne idée, pour éviter aux [ordinateurs](../general/computer.md) d'utiliser le mauvais [écran](screen1.md) ou pour éviter qu'une surcharge de composants survienne (ce qui provoque le crash de l'[ordinateur](../general/computer.md) et l'empêche de démarrer).
|
||||
|
||||
Il y a également une version sans-fil de ce bloc, appelée le [point d'accès](accessPoint.md), qui peut aussi relayer des messages sans-fil. Les messages sans-fil peuvent être reçus et relayés par d'autres [points d'accès](accessPoint.md), ou par des [ordinateurs](../general/computer.md) équipés d'une [carte réseau sans-fil](../item/wlanCard.md).
|
||||
|
||||
Les routeurs et [points d'accès](accessPoint.md) ne gardent *pas* de trace des paquets qu'ils ont récemment relayé, donc évitez les boucles dans votre réseau ou vous pourriez recevoir le même paquet plusieurs fois. A cause de la taille limitée de la mémoire tampon des routeurs, une perte des paquets peut survenir si vous essayez d'envoyer des messages réseau trop fréquemment. Vous pouvez améliorer vos routeurs et points d'accès pour augmenter la vitesse à laquelle ils relaient les messages, ainsi que la taille interne de la file des messages.
|
||||
|
||||
Les paquets sont seulement renvoyés un certain nombre de fois, donc enchaîner un certain nombre de [routeurs](switch.md) ou de points d'accès n'est pas possible. Par défaut, un paquet sera renvoyé jusqu'à 5 fois.
|
||||
@ -0,0 +1,9 @@
|
||||
# Transposeur
|
||||
|
||||
|
||||
|
||||
Le transposeur fait le lien entre les entonnoirs controlés par la redstone et les [robots](robot.md), ce qui permet le transfert d'objets et de fluides entre des blocs voisins contrôlé par [ordinateur](../general/computer.md).
|
||||
|
||||
*Notez que ce bloc n'a pas d'inventaire interne.*
|
||||
|
||||
A part déplacer des choses, il peut également être utilisé pour inspecter le contenu d'inventaires voisins, comme le ferait un [adaptateur](adapter.md) avec une [amélioration de contrôle d'inventaire](../item/inventoryControllerUpgrade.md), ou le contenu de réservoirs voisins, comme un adaptateur avec une [amélioration de contrôle de réservoir](../item/inventoryControllerUpgrade.md).
|
||||
@ -0,0 +1,9 @@
|
||||
# Point de passage
|
||||
|
||||
|
||||
|
||||
Le point de passage n'a aucune utilité en soi, mais dans la façon dont il peut être utilisé. Les [améliorations de navigation](../item/navigationUpgrade.md) peuvent détecter les points de passage, ainsi les appareils équipés d'une amélioration de navigation peuvent utiliser ces points de passage pour parcourir le monde. C'est particulièrement utile pour écrire des programmes facilement ré-utilisables par des appreils comme les [robots](robot.md) et les [drones](../item/drone.md).
|
||||
|
||||
Remarquez que la position réelle renvoyée lors de la requête par l'amélioration de navigation est *le bloc en face du point de passage* (indiqué par les effets de particule). De cette manière vous pouvez le placer au dessus d'un coffre, et vous référer à la position du point de passage comme étant "au dessus du coffre", sans avoir besoin de prendre en compte dans votre programme la rotation du point de passage.
|
||||
|
||||
Un point de passage a deux propriétés qui peuvent être utilisées en l'interrogeant avec une amélioration de navigation : le puissance actuelle du signal de redstone qu'il reçoit, et un libellé éditable. Le libellé est une chaîne de caractères de 32 caractères qui peut être éditée soit par l'interface soit par le composant exposé par le bloc du point de passage. Ces deux propriétés peuvent ensuite être utilisée sur l'appareil pour déterminer que faire avec le point de passage. Par exemple, un programme de tri pourrait être configuré pour traiter tous les blocs avec un signal de redstone élevé en tant qu'entrée, et ceux avec un signal faible comme une sortie.
|
||||
@ -0,0 +1,10 @@
|
||||
# Ordinateurs
|
||||
|
||||
Les ordinateurs sont fabriqués en utilisant une grande variété de [blocs](../block/index.md) et de composants. Le strict minimum requis pour construire un ordinateur est un [boîtier](../block/case1.md), un [écran](../block/screen1.md), et un [clavier](../block/keyboard.md). Le [boîtier](../block/case1.md) et l'[écran](../block/screen1.md) sont disponibles en différents niveaux fournissant différentes fonctionnalités et permettant d'avoir des systèmes informatiques plus complexes. Pour que l'[écran](../block/screen1.md) soit accessible, le [clavier](../block/keyboard.md) doit être adjacent à l'[écran](../block/screen1.md) (soit sur les côtés, soit directement sur l'[écran](../block/screen1.md)).
|
||||
|
||||
Une fois cette structure de base construite, les composants peuvent être placés dans le [boîtier](../block/case1.md). Ces composants incluent des [processeurs](../item/cpu1.md), de la [mémoire (RAM)](../item/ram1.md), des [disques durs (HDD)](../item/hdd1.md), des [cartes graphiques](../item/graphicsCard1.md) (pour pouvoir utiliser l'[écran](../block/screen1.md)), des [cartes réseau](../item/lanCard.md) (pour communiquer entre réseaux informatiques), etc. Il y a beaucoup de composants disponibles permettant des systèmes souples, conçus à des fins spécifiques.
|
||||
|
||||
Les ordinateurs de niveau inférieur nécessitent également un [lecteur de disquettes](../block/diskDrive.md), qui accepte les [disquettes](../item/floppy.md). Une [disquette](../item/floppy.md) avec [OpenOS](openOS.md) est nécessaire pour démarrer l'ordinateur la première fois, et sert à installer le système d'exploitation sur le [disque dur](../item/hdd1.md). Une fois installé sur le [disque dur](../item/hdd1.md), la [disquette](../item/floppy.md) n'est plus nécessaire. Des logiciels supplémentaires sont également disponibles sous forme de [disquette](../item/floppy.md) (comme le gestionnaire de paquets Open Programs (Open Programs Package Manager, ou OPPM)), et peuvent être récupérés dans les coffres de donjons.
|
||||
|
||||
La dernière étape nécessaire est de d'alimenter l'ordinateur avec une source d'énergie. OpenComputers est compatible avec la plupart des grands mods fournissant de l'énergie, et plusieurs blocs peuvent être alimentés directement. Vous pouvez voir quels blocs peuvent être connectés à une source externe d'énergie en vérifiant si leur infobulle mentionne une vitesse de conversion de l'énergie.
|
||||
Pour un réseau plus grand avec plusieurs ordinateurs, un [convertisseur énergétique](../block/powerConverter.md) (convertit l'énergie de différents mods vers le type d'énergie propre à OC), un [distributeur énergétique](../block/powerDistributor.md) (distribue l'énergie aux ordinateurs sur le réseau) et un [capaciteur](../block/capacitor.md) (stockage d'énergie pour le réseau) peuvent être utilisés pour connecter d'autres ordinateurs sur le réseau en se servant de [câbles](../block/cable.md).
|
||||
@ -0,0 +1,69 @@
|
||||
# Entête avec plusieurs lignes [avec un lien](redirect1.md) et *quelques* autres
|
||||
|
||||
Voici un peu de texte de test pour la version de Markdown supportée par le système de documenation en jeu prévu pour OpenComputers.
|
||||
|
||||
|
||||
*Ceci* est du texte en *italique*, ~~barré~~ peut-être **un peu** de texte **en gras**. Est-ce que _c'est souligné _? Oh, non, _c'est aussi en italique!_ Bon, c'est [un lien](../index.md).
|
||||
|
||||
## Entête plus petite [avec un *lien* aussi mais cette __fois__ plus long](../block/adapter.md)
|
||||
|
||||
|
||||
|
||||
un peu de texte directement au dessus de l'afficheur d'objet pour tester l'espacement
|
||||
|
||||
un peu de texte directement en dessous de l'afficheur d'objet pour tester l'espacement
|
||||
|
||||
Ceci est en *italique
|
||||
sur deux* lignes. Mais *ceci ... non, *ceci est du* *texte* **_en italique gras_**.
|
||||
|
||||
### encore plus petit
|
||||
|
||||
*pas en italique *parce que ** pourquoi le serait-il*eh
|
||||
|
||||
`test de code`
|
||||
`ce n'est pas encore du code`
|
||||
`function f(a)`
|
||||
` testingIndent(a)`
|
||||
` do`
|
||||
` lalala()`
|
||||
` end`
|
||||
`end`
|
||||
ouais, l'espacement des lignes est un peu petit, mais sinon il n'y a pas assez de texte qui tient sur un écran.
|
||||
voici un peu de `code` contenu dans une ligne. puis `un peu plus de CODE qui` fait un retour à la ligne et qui continue.
|
||||
|
||||
n'est pas*.
|
||||
|
||||
# pas une entête
|
||||
|
||||
* c'est un élément de liste et le texte qui reviendra à la ligne sera indenté correctement
|
||||
- ça devrait aussi `fonctionner pour du texte affiché comme du code, si ce n'est pas le cas je` serai une mauvaise personne
|
||||
|
||||
asdasd  qweqwe
|
||||
|
||||
Et finalement, [c'est un lien !](https://avatars1.githubusercontent.com/u/514903).
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
tests de retour à la ligne
|
||||
12345678901234567890.1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
|
||||
`123456789012345678901234567890.12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890`
|
||||
|
||||
* 12345678901234567890.1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890
|
||||
- `123456789012345678901234567890.12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890`
|
||||
|
||||
c'est un test pour uneune image dans une lignekakakakalalsd 123 as
|
||||
|
||||
c'est un test pour une
|
||||
une image avec un retour à la ligne après
|
||||
|
||||
c'est un test pour une
|
||||
|
||||
une image entre deux lignes
|
||||
|
||||
c'est un test pour une
|
||||
|
||||
|
||||
|
||||
une image entre deux lignes vides
|
||||
@ -0,0 +1,16 @@
|
||||
# Lua
|
||||
|
||||
Le [manuel de référence](http://www.lua.org/manual/5.2/manual.html) en Lua et le livre [Programming Lua](http://www.lua.org/pil/) (la première édition est disponible gratuitement en ligne) sont un bon endroit pour démarrer avec les bases de Lua et se familiariser avec la synntaxe de base et les bibliothèques standard. [OpenOS](openOS.md) s'efforce d'émuler les bibliothèques standard au plus près, avec quelques écarts, comme la bibliothèque de débogage qui est principalement absente (pour des raisons de sécurité liées au mode "bac à sable"). Ces différences sont [documentées sur le wiki](http://ocdoc.cil.li/api:non-standard-lua-libs).
|
||||
|
||||
Les bibliothèques non-standard devront être importées avec `require` pour les utiliser dans un script. Par exemple :
|
||||
|
||||
`local component = require("component")`
|
||||
`local rs = component.redstone`
|
||||
|
||||
Cela vous permettra d'appeller toutes les fonctions fournies par le composant de [redstone](../item/redstoneCard1.md). Par exemple :
|
||||
|
||||
`rs.setOutput(require("sides").front, 15)`
|
||||
|
||||
**Important**: quand vous travaillez avec l'interpréteur Lua, n'utilisez *pas* `local`, car les variables seront locales à la ligne. Cela signifie que si vous tapiez les lignes ci-dessus les unes après les autres dans l'interpréteur, la troisième ligne lancerait une erreur, en vous disant que `rs` a une valeur `nil`. Mais dans ce cas, pourquoi seulement la troisième ligne ? Parce que, pour faciliter les tests, l'interpréteur essaye de charger les variables inconnues comme des bibliothèques. Donc même si l'affectation à `component` à la première ligne ne ferait rien, l'utilisation de `component` à la deuxième ligne chargerait cette bibliothèque et l'utiliserait. Les bibliothèques ne sont pas utilisées automatiquement lorsque que vous utilisez des scripts Lua, afin de réduire l'usage de la mémoire, car c'est une ressource limitée.
|
||||
|
||||
OpenOS fournit plusieurs bibliothèques personnalisées qui peuvent être utilisées dans un grand nombre d'applications, allant du contrôle et la manipulation des composants attachés à l'[ordinateur](computer.md), aux APIs de référence pour les couleurs, utilisées pour le contrôle de câbles de redstone empaquetés, et les codes du [clavier](../block/keyboard.md). Des bibliothèques personnalisées peuvent être employée dans un script Lua en utilisant la fonction `require()`, comme ci-dessus. Certaines bibliothèques personnalisées nécessitent des composants spécifiques pour fonctionner, comme la bibliothèque `internet` qui requiert une [carte internet](../item/internetCard.md). Dans ce cas particulier, la bibliothèque est même fournie par la carte, c'est à dire que la bibliothèque apparaîtra une fois que vous aurez installé une carte internet - techniquement parlant, elle est contenue dans un petit fichier en lecture seule sur la carte internet.
|
||||
@ -0,0 +1,12 @@
|
||||
# OpenOS
|
||||
|
||||
OpenOS est un système d'exploitation basique disponible dans OpenComputers. Il est nécessaire pour faire démarrer un [ordinateur](computer.md) pour la première fois, et peut être fabriqué en plaçant une [disquette](../item/floppy.md) vide et un manuel d'OpenComputers dans une table de craft.
|
||||
|
||||
Une fois créée, la [disquette](../item/floppy.md) peut être placée dans un [lecteur de disquette](../block/diskDrive.md) connectée à un système [informatique](computer.md) [correctement configuré](quickstart.md), ce qui permettra à l'[ordinateur](computer.md) de lancer OpenOS.
|
||||
Une fois démarré, il est conseillé d'installer OpenOS sur un [disque dur](../item/hdd1.md) vierge, ce qui évite la nécessité d'une [disquette](../item/floppy.md) et donne accès à un système de fichiers en lecture/écriture (la [disquette](../item/floppy.md) d'OpenOS et les autres disquettes "trouvées" sont en lecture seule). Un [boîtier](../block/case3.md) de niveau 3 n'a pas besoin de [lecteur de disquette](../block/diskDrive.md), car il a un emplacement intégré pour les [disquettes](../item/floppy.md).
|
||||
|
||||
OpenOS peut être installé en écrivant simplement `install`, et en suivant les informations affichées à l'écran pour finaliser l'installation. La [disquette](../item/floppy.md) peut être retirée une fois que le système a été redémarré. OpenOS peut être installé sur tous les appareils sauf les [drones](../item/drone.md) et les [micro-contrôleurs](../block/microcontroller.md) (ils nécessitent tous les deux une programmation manuelle d'une [EEPROM](../item/eeprom.md) pour fournir des fonctionnalités, parce qu'ils n'ont pas de système de fichiers intégré).
|
||||
|
||||
OpenOS a de nombreuses fonctions intégrées, la plus utile d'entre elles étant la commande `lua`, qui ouvre un interpréteur Lua. C'est un bon endroit de test pour essayer diverses commandes, et expérimenter l'API des composants, avant d'écrire les commandes dans un script .lua. Retenez l'information affichée lors du démarrage de l'interpréteur, elle vous expliquera comment afficher le résultat des commandes que vous entrez, et comment en sortir.
|
||||
|
||||
Pour plus d'information sur la programmation, référez vous à la page sur la [programmation en Lua](lua.md). Pour exécuter des scripts Lua, saisissez simplement le nom du fichier et appuyez sur Entrée (par exemple, `script.lua` peut être exécuté en tapant la commande `script` dans le terminal).
|
||||
@ -0,0 +1,52 @@
|
||||
# Bien démarrer
|
||||
|
||||
Aussi connu en tant que "comment construire votre premier ordinateur". Pour faire démarrer votre premier [ordinateur](computer.md), vous aurez d'abord besoin de l'installer correctement. Il y a plusieurs types différents d'ordinateurs dans OpenComputers, mais commençons avec la base : l'ordinateur standard.
|
||||
|
||||
**Avertissement**: ce sera un pas-à-pas, et il fournira des informations sur la manière de chercher des questions vous-même plus tard, donc ça sera plutôt long. Si vous n'avez jamais construit d'ordinateur dans la vie réelle, et/ou que vous êtes complètement nouveau sur ce mod, il est vivement recommandé que vous lisiez tout ceci.
|
||||
|
||||
Premièrement, vous aurez besoin d'un [boîtier](../block/case1.md). C'est le bloc qui contiendra tous les composants, en définissant le comportement de l'ordinateur que vous construisez.
|
||||
|
||||
|
||||
|
||||
Par exemple, vous aurez besoin de choisir quel niveau de [carte graphique](../item/graphicsCard1.md) vous voulez utiliser, si vous avez besoin d'une [carte réseau](../item/lanCard.md), une [carte de redstone](../item/redstoneCard1.md) ou, si vous faites des essais en mode créatif, peut être même une [carte de débogueur](../item/debugCard.md).
|
||||
|
||||
Quand vous ouvrez l'interface du [boîtier d'ordinateur](../block/case1.md), vous verrez quelques emplacements à droite. Le nombre d'emplacements, et le niveau des composants qui peuvent être placés dedans (indiqué par le petit chiffre romain dans l'emplacement) dépend du niveau du boîtier lui-même.
|
||||
|
||||
Quand ils sont vides, les [boîtiers](../block/case1.md) sont assez inutiles. Vous pouvez essayer d'allumer votre [ordinateur](computer.md), mais il affichera immédiatement un message d'erreur dans votre tchat, et fera entendre son mécontentement en vous bipant dessus. Heureusement que le message d'erreur vous dit quoi faire pour résoudre la situation : il demande de l'énergie. Connectez votre [ordinateur](computer.md) à un peu d'énergie, soit directement soit via un [convertisseur énergétique](../block/powerConverter.md).
|
||||
|
||||
Maintenant, si vous essayez de le démarrer, il vous dira qu'il a besoin d'un [processeur](../item/cpu1.md). Il en existe de différents niveaux - une tendance dont vous remarquerez la présence partout dans OpenComputers. Pour les [processeurs](../item/cpu1.md), un meilleur niveau signifie plus de composants à la fois, ainsi qu'une vitesse plus élevée. Donc choississez un niveau, et mettez le dans votre [boîtier](../block/case1.md).
|
||||
|
||||
Ensuite, il vous sera demandé d'insérer de la [mémoire (RAM)](../item/ram1.md). Remarquez que le bip est différent maintenant : long-court. De plus hauts niveaux de [mémoire (RAM)](../item/ram1.md) permettent plus de mémoire disponible pour les programmes s'exécutant sur votre [ordinateur](computer.md). Pour lancer [OpenOS](openOS.md), ce qui est le but de cette introduction, vous devrez utiliser au moins deux barettes de [mémoire (RAM)](../item/ram1.md) de niveau 1.
|
||||
|
||||
On progresse bien. Pour le moment, votre [boîtier](../block/case1.md) ressemblera à quelque chose comme ça :
|
||||
|
||||
Et voilà, mettre l'ordinateur sous tension n'affichera plus de message d'erreur ! Hélas, il ne fait quand même pas grand chose. Au moins, il émet 2 bips. Ce qui veut dire que le lancement de l'[ordinateur](computer.md) a échoué. En d'autres termes : techniquement, il fonctionne ! C'est là qu'intervient un outil très utile : l'[analyseur](../item/analyzer.md). Cet outil permet d'inspecter beaucoup de blocs d'OpenComputers, ainsi que quelques blocs d'autres mods. Pour l'utiliser sur l'[ordinateur](computer.md), utilisez l'[analyseur](../item/analyzer.md) sur le boîtier en vous accroupissant.
|
||||
|
||||
Vous devriez maintenant voir l'erreur qui a causé le crash de l'[ordinateur](computer.md) :
|
||||
`no bios found; install configured EEPROM`
|
||||
(aucun BIOS trouvé; installez une EEPROM configurée)
|
||||
|
||||
L'accent ici est mis sur *configured*. Crafter une [EEPROM](../item/eeprom.md) est plutôt simple. Pour la configurer, vous aurez généralement à utiliser un [ordinateur](computer.md) - mais c'est un peu compliqué pour le moment, donc on va utiliser une recette pour fabriquer une [EEPROM](../item/eeprom.md) configurée nommée "Lua BIOS". La recette classique est une [EEPROM](../item/eeprom.md) et un [manuel](../item/manual.md). Mettez l'[EEPROM](../item/eeprom.md) configurée dans l'[ordinateur](computer.md), eeeeet...
|
||||
|
||||
Non. Toujours rien. Mais nous savons quoi faire : le joueur utilise l'[analyseur](../item/analyzer.md), c'est super efficace ! Maintenant nous avons un message d'erreur différent :
|
||||
`no bootable medium found; file not found`
|
||||
(pas de média bootable; fichier non trouvé)
|
||||
|
||||
Bien. Cela veut dire que le BIOS fonctionne. C'est juste qu'il ne trouve pas de système de fichier à partir duquel il peut démarrer, comme une [disquette](../item/floppy.md) ou un [disque dur](../item/hdd1.md). Le BIOS Lua en particulier attend un tel système de fichier pour y trouver un fichier nommé `init.lua` à la racine. Avec l'[EEPROM](../item/eeprom.md), vous écrivez généralement dans un système de fichier avec un [ordinateur](computer.md). Vous l'avez probablement deviné : nous devons maintenant fabriquer notre disque de système d'exploitation. Prenez une [disquette](../item/floppy.md) vierge et un [manuel](../item/manual.md), assemblez les, et vous obtiendrez une disquette d'[OpenOS](openOS.md).
|
||||
|
||||
Maintenant, si vous avez utilisé un [boîtier](../block/case2.md) de niveau 2 comme dans les captures d'écran si dessus, vous n'aurez nulle part où mettre cette disquette. Si vous avez un [boîtier](../block/case2.md) créatif ou de niveau 3, vous pouvez placer la disquette directement dans le [boîtier](../block/case1.md). Sinon vous devrez mettre un [lecteur de disquettes](../block/diskDrive.md) à côté du boîtier (ou le connecter avec des [câbles](../block/cable.md)). Une fois votre disquette insérée, vous savez quoi faire. Appuyez sur le bouton d'alimentation.
|
||||
|
||||
Il vit ! Ou il devrait, en tout cas. Si ce n'est pas le cas quelque chose ne va pas, et vous devriez investiguer en utilisant l'[analyzer](../item/analyzer.md). Mais en supposant qu'il fonctionne maintenant, vous avez presque fini. La partie la plus compliquée est terminée. Tout ce qui reste à faire est de lui permettre d'accepter des entrées, et d'afficher des sorties.
|
||||
|
||||
Pour permettre à l'[ordinateur](computer.md) d'afficher des informations, vous devrez vous munir d'un [écran](../block/screen1.md) et d'une [carte graphique](../item/graphicsCard1.md).
|
||||
|
||||
|
||||
Placez l'[écran](../block/screen1.md) à côté de votre [boîtier](../block/case1.md) ou, à nouveau, connectez le en utilisant des [câbles](../block/cable.md). Puis placez une [carte graphique](../item/graphicsCard1.md) de votre choix dans le [boîtier](../block/case1.md). Vous devriez maintenant voir un curseur clignotant sur l'[écran](../block/screen1.md). Finalement, placez un [clavier](../block/keyboard.md) soit sur l'[écran](../block/screen1.md) lui-même, soit juste en face de l'[écran](../block/screen1.md), pour activer l'entrée de données au [clavier](../block/keyboard.md).
|
||||
|
||||
Avec ça, vous avez fini. L'[ordinateur](computer.md) fonctionne et prêt à l'action. Essayez le maintenant ! Tapez `lua` dans l'interface système et appuyez sur Entrée, et vous serez accueilli par quelques informations sur la manière d'utiliser l'interpréteur Lua. Vous pouvez y tester des commandes Lua de base. Pour plus d'informations à ce sujet, allez sur [la page Lua](lua.md)
|
||||
|
||||
|
||||
|
||||
Amusez vous à construire des [ordinateurs](computer.md) plus complexes, jouer avec des [serveurs](../item/server1.md) et assembler des [robots](../block/robot.md), des [drones](../item/drone.md), des [micro-contrôleurs](../block/microcontroller.md) et des [tablettes](../item/tablet.md) dans l'[assembleur électronique](../block/assembler.md).
|
||||
|
||||
Bon code !
|
||||
39
src/main/resources/assets/opencomputers/doc/fr_FR/index.md
Normal file
39
src/main/resources/assets/opencomputers/doc/fr_FR/index.md
Normal file
@ -0,0 +1,39 @@
|
||||
# Manuel d'OpenComputers
|
||||
|
||||
OpenComputers est un mod qui ajoute au jeu des [ordinateurs](general/computer.md), des [serveurs](item/server1.md), des [robots](block/robot.md), et des [drone](item/drone.md) persistants, modulaires et très configurables. Tous les appareils peuvent être programmés en utilisant Lua 5.2, permettant d'avoir des systèmes à complexité variable en fonction de leur usage.
|
||||
|
||||
Pour apprendre à utiliser ce manuel, allez sur [la page parlant du manuel](item/manual.md) (Ce texte en vert est un lien, vous pouvez cliquer dessus).
|
||||
|
||||
## Table des matières
|
||||
|
||||
### Appareils
|
||||
- [Ordinateurs](general/computer.md)
|
||||
- [Serveurs](item/server1.md)
|
||||
- [Micro-contrôleurs](block/microcontroller.md)
|
||||
- [Robots](block/robot.md)
|
||||
- [Drones](item/drone.md)
|
||||
|
||||
### Logiciel et programmation
|
||||
- [OpenOS](general/openOS.md)
|
||||
- [Lua](general/lua.md)
|
||||
|
||||
### Blocs et objets
|
||||
- [Objets](item/index.md)
|
||||
- [Blocs](block/index.md)
|
||||
|
||||
### Guides
|
||||
- [Bien démarrer](general/quickstart.md)
|
||||
|
||||
## Vue d'ensemble
|
||||
|
||||
Comme indiqué plus haut, les ordinateurs d'OpenComputers sont persistants, ce qui signifie qu'un [ordinateur](general/computer.md) en fonctionnement garde son état quand le chunk dans lequel il se trouve est déchargé. Cela signifie que si un joueur s'éloigne de cet [ordinateur](general/computer.md), ou se déconnecte, l'[ordinateur](general/computer.md) se souviendra de son dernier état connu et reprendra à ce point quand le joueur s'en rapprochera. La persistance fonctionne pour tous les appareils sauf les [tablettes](item/tablet.md)
|
||||
|
||||
Tous les appareils sont modulaires et peuvent être assemblés avec une grande variété de composants, comme les [ordinateurs](general/computer.md) de la vie réelle. Les joueurs qui aiment bricoler seront capables d'optimiser leurs appareils comme ils le souhaitent. Si on le désire, les appareils peuvent être [démontés](block/disassembler.md) et reconstruits si la configuration initiale n'était pas satisfaisante. Pour les [ordinateurs](general/computer.md) et les [serveurs](item/server1.md), les composants peuvent être échangés à la volée simplement en ouvrant l'interface correspondante.
|
||||
|
||||
Les appareils d'OpenComputers sont compatibles avec différents mods pour la manipulation de blocs et d'entités (à travers l'[adaptateur](block/adapter.md), ou des améliorations spécifiques d'un [robot](block/robot.md) ou d'un [drone](item/drone.md)). L'énergie peut être fournie grâce à une large gamme de mods, incluant, sans limitation, les Redstone Flux, les EU d'IndustrialCraft2, les Joules de Mekanism, l'énergie d'Applied Energistics 2 autant que la charge de Factorization.
|
||||
|
||||
Les appareils d'OpenComputers ont des fonctionnalités supplémentaires ainsi que quelques limitations. Les [ordinateurs](general/computer.md) sont la base, et sont capables de contenir un bon nombre de composants, contrôlés par le niveau du processeur utilisé. Les [ordinateurs](general/computer.md) ont également accès aux composants par leurs six faces. Les [serveurs](item/server1.md) sont capables de se connecter à plus de composants (en interne ou en externe) qu'un [ordinateur](general/computer.md), en utilisant des [bus de composants](item/componentBus1.md); cependant, à cause du [support de serveur](block/serverRack.md), le [serveur](item/server1.md) est seulement capable d'accéder aux composants par une unique face du [support de serveur](block/serverRack.md), tel que configuré dans l'interface du [server rack](block/serverRack.md). Les [micro-contrôleurs](block/microcontroller.md) sont encore plus limités (comparés aux [ordinateurs](general/computer.md)) par leur manque d'emplacements de [disque dur](item/hdd1.md) et de [lecteur de disquette](block/diskDrive.md), ce qui veut dire qu'[OpenOS](general/openOS.md) ne peut pas être installé sur un [micro-contrôleur](block/microcontroller.md). Les [micro-contrôleurs](block/microcontroller.md) ont un emplacement pour une [EEPROM](item/eeprom.md), et peuvent être programmés avec un système d'exploitation plus spécifique pour un ensemble limité de tâches.
|
||||
|
||||
Les [robots](block/robot.md) sont des [ordinateurs](general/computer.md) mobiles, et sont capables d'interagir avec le monde (mais ne peuvent pas interagir avec d'autres blocs d'OpenComputers). Contrairement aux [ordinateurs](general/computer.md), une fois qu'un robot est construit, les composants à l'intérieur du [robot](block/robot.md) ne peuvent pas être retirés. Pour contourner cette limitation, les [robots](block/robot.md) peuvent être construits avec des conteneurs d'[amélioration](item/upgradeContainer1.md) ou de [carte](item/cardContainer1.md), ce qui permettra d'échanger à la volée des cartes ou des améliorations, si nécessaire. [OpenOS](general/openOS.md) peut être installé sur les [robots](block/robot.md) en plaçant un [lecteur de disquette](block/diskDrive.md) dans un emplacement de conteneur, ce qui permettra l'insertion de [disquettes](item/floppy.md), ou en plaçant un [disque dur](item/hdd1.md) avec [OpenOS](general/openOS.md) pré-installé dans l'un des emplacements de [disque dur](item/hdd1.md). Pour complètement reconfigurer un [robot](block/robot.md), il devra être [désassemblé](block/disassembler.md) avant. Les [drones](item/drone.md) sont une version limitée des [robots](block/robot.md). Ils se déplacent différemment, ont moins d'emplacements d'inventaire, et n'ont pas de système d'exploitation (à l'instar des [micro-contrôleurs](block/microcontroller.md), les [drones](item/drone.md) peuvent être configurés avec une [EEPROM](item/eeprom.md) programmée pour un ensemble limité de tâches). Pour la plupart, les [robots](block/robot.md) et les [drones](item/drone.md) partagent les mêmes améliorations et composants; cependant, les améliorations se comportent différemment avec les [drones](item/drone.md), comme les [améliorations d'inventaire](item/inventoryUpgrade.md) qui fournissent seulement 4 emplacements par amélioration, pour un total de 8 emplacements, tandis que les [robots](block/robot.md) sont capables d'accepter plus d'[améliorations d'inventaire](item/inventoryUpgrade.md) (pour un total de 4) ainsi que l'obtention de plus d'emplacements par amélioration (16 emplacements par amélioration).
|
||||
|
||||
Ce manuel contient des informations détaillées concernant tous les blocs et objets, comment mettre en place différents types de systèmes et d'appareils, ainsi qu'une introduction à la programmation.
|
||||
@ -0,0 +1,5 @@
|
||||
# Carte de bus abstraite
|
||||
|
||||
|
||||
|
||||
Cette carte permet aux [ordinateurs](../general/computer.md), aux [serveurs](server1.md) et aux [robots](../block/robot.md) d'interagir avec le bus d'abstraction de StargateTech2. Quand la carte est installée, ces blocs se connecteront au bus d'abstraction et un composant devient disponible aux machines, pour envoyer des messages à travers le bus d'abstraction. Les messages entrants du bus d'abstraction sont convertis en signaux qui sont injectés dans la machine.
|
||||
@ -0,0 +1,9 @@
|
||||
# Grog
|
||||
|
||||
|
||||
|
||||
Cette délicieuse [citation nécessaire] mixture peut être consommée si jamais vous ressentez le besoin de vous... amuser. Ou de détruire votre tube digestif. Ou les deux. Il peut également servir en tant qu'ingrédient pour d'autres objets beaucoup plus utiles.
|
||||
|
||||
L'un des usages principaux, pourtant, est de retirer de votre organisme des [nanomachines](nanomachines.md), si vous n'en voulez plus. Le boire est le seul moyen de s'en débarasser !
|
||||
|
||||
En utilisant les recettes du mode difficile, il est utilisé pour graver les [plaques de circuit imprimé](circuitBoard.md) avant de fabriquer les [circuits imprimés](printedCircuitBoard.md).
|
||||
@ -0,0 +1,5 @@
|
||||
# Unité de Logique Arithmétique
|
||||
|
||||
|
||||
|
||||
Elle est utilisée pour fabriquer des composants effectuant des calculs, comme les [processeurs](cpu1.md) et les [cartes graphiques](graphicsCard1.md).
|
||||
@ -0,0 +1,7 @@
|
||||
# Analyseur
|
||||
|
||||
|
||||
|
||||
L'analyseur est un outil très pratique pour afficher des informations les blocs liés à OpenComputers. Cliquez simplement sur un bloc (en étant éventuellement accroupi) pour afficher quelques informations dans la zone de chat. Cela va de choses basiques comme l'adresse des composants, aux niveaux d'énergie du sous-réseau dont le bloc fait partie, jusqu'aux informations sur l'erreur qui a mené un [ordinateur](../general/computer.md) à planter, par exemple.
|
||||
|
||||
Une autre fonctionnalité est la copie de l'adresse d'un composant dans le presse-papier, qui est effectuée en faisant un Ctrl-clic droit sur le bloc ou le composant. Cette information peut être collée dans un terminal d'[ordinateur](../general/computer.md) par la suite.
|
||||
@ -0,0 +1,5 @@
|
||||
# Amélioration Ange
|
||||
|
||||
|
||||
|
||||
Cette amélioration permet aux [robots](../block/robot.md) de placer des blocs en l'air, sans bloc de soutien.
|
||||
@ -0,0 +1,7 @@
|
||||
# Unité de Traitement Accélérée (UTA)
|
||||
|
||||
|
||||
|
||||
Cet élément est la parfaite union d'un [processeur](cpu1.md) et d'une [carte graphique](graphicsCard1.md). En utiliser une revient à vous laisser un emplacement de carte supplémentaire. Comme un processeur normal, elle définit l'architecture de l'[ordinateur](../general/computer.md), et le nombre de composants qui peuvent être connectés à l'[ordinateur](../general/computer.md) avant qu'il ne puisse plus fonctionner. De plus, elle fournit des fonctionnalités graphiques de base.
|
||||
|
||||
Remarquez qu'à cause de l'espace limité sur la puce, ces processeurs sont légèrement plus lents que leur équivalent "pur", et affichent des graphismes avec une plus faible fidélité. Donc si une UTA de niveau 1 peut contrôler autant de composants qu'un processeur de niveau 2, elle fonctionne à la même vitesse qu'un processeur de niveau 1, et affiche seulement des graphismes avec la même fidélité qu'une carte graphique de niveau 1.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT apu1.md
|
||||
@ -0,0 +1,5 @@
|
||||
# Touches directionnelles
|
||||
|
||||
|
||||
|
||||
Au risque de me répéter : c'est la crise des touches. Parce que l'économie des touches a connu une sérieuse inflation ces dernières années. Elles sont utilisées pour fabriquer des [claviers](../block/keyboard.md).
|
||||
@ -0,0 +1,5 @@
|
||||
# Amélioration de batterie
|
||||
|
||||
|
||||
|
||||
Cette amélioration augmente la quantité maximale d'énergie stockée par les appareils, comme les [robots](../block/robot.md) et les [tablettes](tablet.md), ce qui leur permet de fonctionner plus longtemps sans devoir revenir vers un [chargeur](../block/charger.md). Les améliorations de batterie de niveau supérieur peuvent stocker plus d'énergie.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT batteryUpgrade1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT batteryUpgrade1.md
|
||||
@ -0,0 +1,5 @@
|
||||
# Groupe de boutons
|
||||
|
||||
|
||||
|
||||
Parce que vous avez *toujours* plein de boutons qui trainent quelque part. Ne mentez pas. Nous avons tous à faire un Maj-clic sur ce bouton de recette, encore et encore. Les groupes de boutons sont utilisés pour fabriquer des [claviers](../block/keyboard.md).
|
||||
@ -0,0 +1,5 @@
|
||||
# Base de carte
|
||||
|
||||
|
||||
|
||||
C'est un matériau communément utilisé pour fabriquer des cartes dans OpenComputers (comme les [cartes graphiques](graphicsCard1.md), les [cartes réseau](lanCard.md), etc.).
|
||||
@ -0,0 +1,5 @@
|
||||
# Conteneur de carte
|
||||
|
||||
|
||||
|
||||
Le conteneur de carte est une amélioration de conteneur pour que des cartes puissent être insérées ou retirées d'un [robot](../block/robot.md) à la volée. Le niveau maximum de la carte que l'emplacement peut contenir est égal au niveau du conteneur. Contrairement aux amélioration classiques, la complexité des conteneurs est de deux fois leur niveau. Regardez [par là](../block/robot.md) pour avoir des détails sur la complexité des robots.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT cardContainer1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT cardContainer1.md
|
||||
@ -0,0 +1,9 @@
|
||||
# Chamélium
|
||||
|
||||
|
||||
|
||||
Le chamélium est un matériau métamorphe qui est utilisé pour créer des [impressions 3D](../block/print.md) dans une [imprimante 3D](../block/printer.md). De lui même, il n'a aucune utilité, mais est très pratique pour créer des zones simples et entièrement monochromes.
|
||||
|
||||
Vous pouvez également le combiner pour créer un [bloc de chamélium](../block/chameliumBlock.md).
|
||||
|
||||
Comme l'indique l'info-bulle, le manger peut provoquer des effets secondaires indésirables, donc consommez le avec parcimonie. Ou mieux, n'en mangez pas du tout.
|
||||
@ -0,0 +1,5 @@
|
||||
# Puce électronique
|
||||
|
||||
|
||||
|
||||
Les puces électroniques sont le pain quotidien de la fabrication de composants électroniques. Elles existent en différents niveaux, pour fabriquer différents niveaux de composants.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT chip1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT chip1.md
|
||||
@ -0,0 +1,7 @@
|
||||
# Amélioration chargement de chunk
|
||||
|
||||
|
||||
|
||||
L'amélioration de chargement de chunk peut être installée sur des appareils (comme les [robots](../block/robot.md) et les [microcontrôleurs](../block/microcontroller.md)) pour leur permettre de garder le chunk dans lequel ils sont - ainsi que les chunks environnants - chargés. Cela consomme de l'énergie, cependant. Le chargeur de chunks peut être activé et désactivé par l'API du composant exposé à l'appareil.
|
||||
|
||||
Cette amélioration est automatiquement activée quand l'appareil est mis sous tension, et automatiquement désactivée quand l'appareil est éteint.
|
||||
@ -0,0 +1,5 @@
|
||||
# Plaque de circuit imprimé
|
||||
|
||||
|
||||
|
||||
C'est un objet intermédiaire fait à partir de [plaques de circuit imprimé brutes](rawCircuitBoard.md) et utilisé pour fabriquer des [circuits imprimés](printedCircuitBoard.md).
|
||||
@ -0,0 +1,10 @@
|
||||
# Bus des composants
|
||||
|
||||
|
||||
|
||||
Un bus des composants est une amélioration dédiée aux [serveurs](server1.md) qui permet à un [serveur](server1.md) de communiquer avec plus de composants à la fois, sans s'éteindre. Comme avec les [processeurs](cpu1.md), un bus de plus haut niveau augmente la limite des composants. Les [serveurs](server1.md) de plus haut niveau sont également capables d'accepter plus de bus de composants, ce qui permet de communiquer avec encore plus de composants.
|
||||
|
||||
Le nombre de composants que chaque bus de composant accepte est le suivant :
|
||||
- Niveau 1: 8 composants.
|
||||
- Niveau 2: 12 composants.
|
||||
- Niveau 3: 16 composants.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT componentBus1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT componentBus1.md
|
||||
@ -0,0 +1,5 @@
|
||||
# Unité de contrôle
|
||||
|
||||
|
||||
|
||||
Un objet de fabrication de haut niveau utilisé dans des circuits avancés, comme les [processeurs](cpu1.md).
|
||||
@ -0,0 +1,14 @@
|
||||
# Processeur
|
||||
|
||||
|
||||
|
||||
L'unité centrale de traitement (ou *central processing unit (CPU)* en anglais) est un composant essentiel à chaque [ordinateur](../general/computer.md) ou [serveur](server1.md). Il définit l'architecture de l'[ordinateur](../general/computer.md), et le nombre de composants qui peuvent être connectés à l'[ordinateur](../general/computer.md) avant qu'il ne cesse de fonctionner. Un processeur de plus haut niveau permet également d'avoir plus d'appels par tick à l'[ordinateur](../general/computer.md) - en d'autres termes : plus le processeur est puissant, plus il est rapide.
|
||||
|
||||
Le nombre de composants qu'un processeur accepte est le suivant :
|
||||
- Niveau 1: 8 composants.
|
||||
- Niveau 2: 12 composants.
|
||||
- Niveau 3: 16 composants.
|
||||
|
||||
Dans un [serveur](server1.md), le nombre de composants supportés peut être augmenté en installant des [bus de composants](componentBus1.md).
|
||||
|
||||
Si plus de composants que le nombre maximal sont connectés à un [ordinateur](../general/computer.md), il ne pourra plus démarrer, et s'il fonctionnait, il crashera.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT cpu1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT cpu1.md
|
||||
@ -0,0 +1,5 @@
|
||||
# Amélioration d'artisanat
|
||||
|
||||
|
||||
|
||||
L'amélioration d'artisanat permet aux [robots](../item/inventoryUpgrade.md) de réaliser des recettes avec et sans forme en utilisant leur [inventaire](../item/inventoryUpgrade.md). Pour fabriquer, la grille de 3x3 en haut à gauche de l'[inventaire](../item/inventoryUpgrade.md) du [robot](../block/robot.md) est utilisée comme grille de fabrication. Les objets doivent être arrangés selon la recette. Les résultats seront replacés dans l'[inventaire](../item/inventoryUpgrade.md) du [robot](../block/robot.md). Comme pour les objets ramassés par terre, le résultat sera placé dans l'emplacement sélectionné; s'il n'y arrive pas, l'objet sera placé dans l'emplacement vide suivant. S'il n'y a plus de place libre, le résultat sera lâché par terre.
|
||||
@ -0,0 +1,5 @@
|
||||
# Fil de coupe
|
||||
|
||||
|
||||
|
||||
Un objet qui n'existe que si vous utilisez les recettes difficiles, il est utilisé pour fabriquer des [plaques de circuit imprimé brutes](rawCircuitBoard.md). Très inefficacement.
|
||||
@ -0,0 +1,7 @@
|
||||
# Carte de données
|
||||
|
||||
|
||||
|
||||
La carte de données est une carte utilitaire qui fournit quelques algorithmes qui seraient soit compliqués à implémenter sur une architecture, soit lent à l'exécution. Elle fournit des fonctionnalités de hachage, ainsi que des fonctionnalités d'inflation/déflation. De plus, elle contient un système de fichiers qui fournit un certain nombre de programmes en utilisant les fonctionnalités de la carte, comme la carte internet.
|
||||
|
||||
Gardez en tête qu'il y a une limite à la taille des données qui peuvent être traitées en même temps, et que chaque opération consomme un peu d'énergie.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT dataCard1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT dataCard1.md
|
||||
@ -0,0 +1,9 @@
|
||||
# Amélioration de base de données
|
||||
|
||||
|
||||
|
||||
L'amélioration de base de données peut être configurée pour stocker un liste de représentation de groupes d'objets, qui peuvent ensuite être utilisés par d'autres composants. C'est particulièrement utile pour les objets qui sont uniquement distinguables par leurs données NBT, ce qui ne fait pas partie des données affichées de base pour un groupe d'objets.
|
||||
|
||||
Pour configurer une base de données, ouvrez la en faisant un clic droit avec la base de données dans la main. Placez les objets avec lesquels vous souhaitez la configurer dans l'inventaire du haut. Cela stockera un "objet fantôme", ce qui veut dire qu'aucun objet "réel" n'est stocké dans la base de données.
|
||||
|
||||
Autrement, la base de données peut être configurée automatiquement en utilisant l'API du composant fournie par les [améliorations du contrôleur d'inventaire](inventoryControllerUpgrade.md) et les [géolyseurs](../block/geolyzer.md).
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT databaseUpgrade1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT databaseUpgrade1.md
|
||||
@ -0,0 +1,7 @@
|
||||
# Carte de débogueur
|
||||
|
||||
|
||||
|
||||
La carte de débogueur est un objet à usage créatif seulement, qui a été créé à l'origine pour rendre le débogage plus facile, en automatisant certains processus. Depuis, elle a obtenu beaucoup d'autres fonctionnalités, ce qui la rend très utile pour la création de cartes personnalisées.
|
||||
|
||||
Remarquez que vous pouvez l'activer en étant accroupi pour la lier à vous, ou pour la détacher, ce qui fera s'exécuter la commande `runCommand` avec votre niveau de permission, au lieu du niveau par défaut d'OpenComputers.
|
||||
@ -0,0 +1,5 @@
|
||||
# Disque
|
||||
|
||||
|
||||
|
||||
Un composant de fabrication de base, utilisé pour fabriquer des moyens de stockage de données, comme des [disquettes](floppy.md) et des [disques durs](hdd1.md).
|
||||
@ -0,0 +1,5 @@
|
||||
# Drone
|
||||
|
||||
|
||||
|
||||
Les drones sont faits en mettant un [boîtier de drone](droneCase1.md) dans un [assembleur](../block/assembler.md). Ce sont des [robots](../block/robot.md) sous forme d'entité, moins chers mais avec moins de fonctionnalités. Ils sont également capables de se déplacer différemment et beaucoup plus vite que les [robots](../block/robot.md), et ils sont généralement controlés en utilisant un programme client sur un [ordinateur](../general/computer.md). Le drone devra avoir une [EEPROM](eeprom.md) configurée pour écouter les commandes entrantes à exécuter, ou pour agir de lui même.
|
||||
@ -0,0 +1,34 @@
|
||||
# Boitier de drone
|
||||
|
||||
|
||||
|
||||
Le boitier de drone est utilisé pour construire des [drones](drone.md) dans l'[assembler](../block/assembler.md). Les [drones](drone.md) sont des machines légères, rapides et très mobiles avec des fonctionnalités réduites (moins d'améliorations et d'emplacements de composant disponibles). Contrairement aux [robots](../block/robot.md), ils ne peuvent pas utiliser d'outils, et peuvent seulement interagir avec le monde de manière relativement limitée.
|
||||
|
||||
Ils compensent leurs limitations par leur vitesse et leur faible coût de fonctionnement en énergie. Ils sont bien adaptés au transport de petites quantités d'objets, et sont idéaux pour de la reconnaissance. Appairer un [drone](drone.md) à un [robot](../block/robot.md) peut être très intéressant, si le [robot](../block/robot.md) fait le "gros" du travail, et que le [drone](drone.md) fournit des informations sur l'environnement et transporte les objets vers et depuis un point central, par exemple.
|
||||
|
||||
Comme les [micro-contrôleurs](../block/microcontroller.md), les [drones](drone.md) peuvent seulement être programmés en utilisant leur [EEPROM](eeprom.md). Par conséquent, l'[EEPROM](eeprom.md) peut être changée en re-fabriquant le [drone](drone.md) avec une autre [EEPROM](eeprom.md); l'[EEPROM](eeprom.md) existante sera rendue dans l'inventaire du joueur.
|
||||
|
||||
Le boitier de drone de niveau 1 est capable d'accepter les composants suivants:
|
||||
- 1x [processeur](cpu1.md) de niveau 1
|
||||
- 1x [barette de RAM](ram1.md) de niveau 1
|
||||
- 1x [EEPROM](eeprom.md)
|
||||
- 1x carte d'extension (niveau 2)
|
||||
- 1x carte d'extension (niveau 1)
|
||||
- 1x amélioration (niveau 1)
|
||||
- 1x amélioration (niveau 2)
|
||||
|
||||
Le boitier de drone de niveau 2 est capable d'accepter les composants suivants:
|
||||
- 1x [processeur](cpu1.md) de niveau 1
|
||||
- 2x [barettes de RAM](ram1.md) de niveau 1
|
||||
- 1x [EEPROM](eeprom.md)
|
||||
- 2x cartes d'extension (niveau 2)
|
||||
- 1x amélioration (niveau 1)
|
||||
- 1x amélioration (niveau 2)
|
||||
- 1x amélioration (niveau 3)
|
||||
|
||||
Le boitier de drone de niveau 4 (Créatif) est capable d'accepter les composants suivants:
|
||||
- 1x [processeur](cpu3.md) de niveau 3
|
||||
- 2x [barettes de RAM](ram5.md) de niveau 3
|
||||
- 1x [EEPROM](eeprom.md)
|
||||
- 3x cartes d'extension (niveau 3)
|
||||
- 9x améliorations (niveau 3)
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT droneCase1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT droneCase1.md
|
||||
@ -0,0 +1,7 @@
|
||||
# EEPROM
|
||||
|
||||
|
||||
|
||||
L'EEPROM est ce qui contient le code utilisé pour initialiser un ordinateur quand il démarre. Les données sont stockées dans un tableau d'octets, et peuvent avoir différentes significations pour différentes architectures de [processeur](cpu1.md). Par exemple, pour Lua, c'est généralement un petit script qui recherche les systèmes de fichier avec un script d'initialisation, pour d'autres architectures ça pourrait être du code machine.
|
||||
|
||||
Les EEPROMs peuvent être programmées pour un usage spécifique, comme les [drones](drone.md) et les [microcontrôleurs](../block/microcontroller.md).
|
||||
@ -0,0 +1,9 @@
|
||||
# Amélioration d'expérience
|
||||
|
||||
|
||||
|
||||
L'amélioration d'expérience est une amélioration très spéciale, puisqu'elle permet aux [robots](../block/robot.md) et aux [drones](drone.md) pour collecter l'expérience en accomplissant de nombreuses actions, comme de casser des blocs de minerai ou de tuer des entités. Une simple amélioration peut stocker jusqu'à 30 niveaux, en fournissant un bonus passif par niveau d'expérience, comme de plus grandes vitesses de récolte et une capacité d'énergie accrue.
|
||||
|
||||
Les [robots](../block/robot.md) au niveau 10 et plus auront une teinte dorée, et ceux qui sont au niveau 20 et plus auront une teinte de diamant.
|
||||
|
||||
L'expérience réelle est stockée dans l'amélioration, ce qui signifie que si l'amélioration est transférée à un autre appareil, l'expérience l'est également.
|
||||
@ -0,0 +1,5 @@
|
||||
# Disquette
|
||||
|
||||
|
||||
|
||||
La disquette est le moyen de stockage de données le moins cher et le plus petit dans OpenComputers. C'est une manière très pratique de stocker des données et de les transférer entre les [ordinateurs](../general/computer.md) et les [robots](../block/robot.md) dès le début de la partie. Vous pourrez également trouver des disquettes avec des programmes utiles dans des coffres de donjons (le gestionnaire de paquets Open Programs est un bon exemple, ce qui permet d'installer facilement des programmes à partir d'un dépôt GitHub central).
|
||||
@ -0,0 +1,7 @@
|
||||
# Amélioration de générateur
|
||||
|
||||
|
||||
|
||||
L'amélioration de générateur permet aux appareils de se recharcher à la volée. Pour le moment elle supporte seulement les carburants solides, comme le charbon. Elle a un inventaire interne qui peut stocker un groupe plein de carburant. Le carburant en surplus peut être retiré du générateur en utilisant la méthode appropriée de l'API du composant. En retirant une amélioration du générateur d'un [robot](../block/robot.md), son contenu sera lâché par terre.
|
||||
|
||||
L'efficacité des générateurs est plus faible que celle de la plupart des générateurs d'autres mods, ce qui signifie qu'il est généralement plus efficicace d'alimenter vos appareils avec un [chargeur](../block/charger.md).
|
||||
@ -0,0 +1,7 @@
|
||||
# Carte graphique
|
||||
|
||||
|
||||
|
||||
La carte graphique est un composant essentiel pour la plupart des [ordinateurs](../general/computer.md), elle leur permet d'afficher du texte sur un [écran](../block/screen1.md) qui leur est connecté. La carte graphique a plusieurs niveaux, et comme les [écrans](../block/screen1.md), elle supporte différentes résolutions et profondeurs de couleur.
|
||||
|
||||
Une autre différence notable pour les différents niveaux de la carte graphique est le nombre d'opérations qu'une carte graphique peut effectuer par tick. Les valeurs affichées sur l'infobulle d'une carte graphique sont représentatives pour un [ordinateur](../general/computer.md) avec un [processeur](cpu1.md) de niveau 2. Les processeurs de niveau 1 fonctionnent un peu plus lentement, et ceux de niveau 3 fonctionnent un peu plus vite. Les nombres affichés représentent les différentes opérations fournies par le processeur graphique : `copy`, `fill`, `set`, `setBackground` et `setForeground`, respectivement.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT graphicsCard1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT graphicsCard1.md
|
||||
@ -0,0 +1,5 @@
|
||||
# Disque dur
|
||||
|
||||
|
||||
|
||||
Le disque dur est un moyen de stockage de données de haut niveau dans OpenComputers. Tous les moyens de stockage de données fonctionnent à la même vitesse ; un moyen de stockage de plus haut niveau fournit juste plus d'espace. Il y a également quelques appareils qui peuvent seulement utiliser les disques durs (bien que les serveurs pourraient utiliser un [lecteur de disquette](../block/diskDrive.md) externe, par exemple). Les disques durs peuvent être placés dans un [raid](../block/raid.md), ce qui permet à plusieurs disques de partager le même système de fichiers. Remarquez que placer un disque dur dans un [raid](../block/raid.md) efface le contenu du disque.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT hdd1.md
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT hdd1.md
|
||||
@ -0,0 +1,11 @@
|
||||
# Bottes de vol plané
|
||||
|
||||
|
||||
|
||||
Si vous ne voulez pas vous embêter à programmer un [drone](drone.md), voici un usage alternatif : un tremplin ! Ou de glorieux patins à roulettes. Un truc du genre.
|
||||
|
||||
Dans tous les cas, ces bottes ont quelques propriétés intéressantes : tant qu'elles ont de l'énergie elles vous permettront de sauter plus haut, et d'absorber le choc de l'aterrissage après un saut particulièrement haut. Techniquement, elles vous permettront de sauter jusqu'à 4 blocs de haut et de réduire les dommages de chute d'un tiers.
|
||||
|
||||
De plus, puisqu'elles permettent toujours de planer d'une certaine manière, elles vous permettront de grimper 1 bloc de haut sans sauter. C'est particulièrement utile quand vous sprintez sur une montagne, par exemple, un endroit très courant chez les Minecrafteurs pour faire du fitness. Enfin, de ce que j'en sais.
|
||||
|
||||
Les bottes peuvent être rechargées dans un [chargeur](../block/charger.md) d'OpenComputers ou dans n'importe quel autre appareil similaire, comme le chargeur d'Applied Energistics, la boîte d'énergie d'IndustrialCraft 2, ou l'infuseur énergétique de Thermal Expansion.
|
||||
@ -0,0 +1,14 @@
|
||||
# Amélioration de vol plané
|
||||
|
||||
|
||||
|
||||
L'amélioration de vol plané permet aux [robots](../block/robot.md) de voler beaucoup plus au dessus du sol que ce qu'ils pourraient le faire normalement. Contrairement aux [drones](drone.md), ils sont limités par défaut à une hauteur de vol de 8 blocs. Ca n'est généralement pas un problème, parce qu'ils peuvent tout de même monter aux murs. Leurs règles de déplacement peuvent être résumées ainsi :
|
||||
- Les robots peuvent seulement bouger si la position de départ ou d'arrivée est valide (par exemple pour un pont).
|
||||
- La position en dessous d'un robot est toujours valide (ils peuvent toujours descendre).
|
||||
- Les positions jusqu'à `flightHeight` au dessus d'un bloc solide sont valides (capacités de vol limitées).
|
||||
- N'importe quelle position avec un bloc adjacent ayant une face solide tournée vers la nouvelle position est valide (les robots peuvent "grimper").
|
||||
|
||||
Ces règles, à part la règle 2 pour la clarté (ils peuvent toujours descendre), peuvent être visualisées comme ça :
|
||||
|
||||
|
||||
Si vous ne souhaitez pas vous préoccuper des limitations de hauteur de vol, ces améliorations sont ce que vous cherchez.
|
||||
@ -0,0 +1 @@
|
||||
#REDIRECT hoverUpgrade1.md
|
||||
@ -0,0 +1,90 @@
|
||||
# Objets
|
||||
|
||||
Cet index liste tous les objets documentés d'OpenComputers. Si vous cherchez un bloc, allez plutôt voir l'[index des blocs](../block/index.md).
|
||||
|
||||
Gardez en tête que certains d'entre eux ne sont pas disponibles, en fonction de l'ensemble de recettes sélectionné.
|
||||
|
||||
## Outils
|
||||
* [Analyseur](analyzer.md)
|
||||
* [Manuel](manual.md)
|
||||
* [Terminal à distance](terminal.md)
|
||||
* [Ramasseur de texture](texturePicker.md)
|
||||
* [Crisseur](wrench.md)
|
||||
|
||||
## Appareils
|
||||
* [Drone](drone.md)
|
||||
* [Serveur](server1.md)
|
||||
* [Tablette](tablet.md)
|
||||
|
||||
## Composants
|
||||
|
||||
### Cartes
|
||||
* [Carte de bus abstraite](abstractBusCard.md)
|
||||
* [Carte de données](dataCard1.md)
|
||||
* [Carte de débogueur](debugCard.md) (ou Interface de Carte Aventure)
|
||||
* [Carte graphique](graphicsCard1.md)
|
||||
* [Carte internet](internetCard.md)
|
||||
* [Carte liée](linkedCard.md)
|
||||
* [Carte réseau](lanCard.md)
|
||||
* [Carte de Redstone](redstoneCard1.md)
|
||||
* [Carte de réseau sans-fil](wlanCard.md)
|
||||
* [Carte de capteur du monde](worldSensorCard.md)
|
||||
|
||||
### Améliorations
|
||||
* [Amélioration ange](angelUpgrade.md)
|
||||
* [Amélioration batterie](batteryUpgrade1.md)
|
||||
* [Conteneur de carte](cardContainer1.md)
|
||||
* [Amélioration chargement de chunk](chunkloaderUpgrade.md)
|
||||
* [Amélioration d'artisanat](craftingUpgrade.md)
|
||||
* [Amélioration de base de données](databaseUpgrade1.md)
|
||||
* [Amélioration d'expérience](experienceUpgrade.md)
|
||||
* [Amélioration de générateur](generatorUpgrade.md)
|
||||
* [Amélioration de vol plané](hoverUpgrade1.md)
|
||||
* [Amélioration du contrôleur d'inventaire](inventoryControllerUpgrade.md)
|
||||
* [Amélioration d'inventaire](inventoryUpgrade.md)
|
||||
* [Amélioration de laisse](leashUpgrade.md)
|
||||
* [Amélioration de navigation](navigationUpgrade.md)
|
||||
* [Amélioration de piston](pistonUpgrade.md)
|
||||
* [Amélioration de panneau d'E/S](signUpgrade.md)
|
||||
* [Amélioration du générateur solaire](solarGeneratorUpgrade.md)
|
||||
* [Amélioration du contrôleur de réservoir](tankControllerUpgrade.md)
|
||||
* [Amélioration de réservoir](tankUpgrade.md)
|
||||
* [Amélioration du rayon tracteur](tractorBeamUpgrade.md)
|
||||
* [Amélioration de conteneur](upgradeContainer1.md)
|
||||
|
||||
### Autre
|
||||
* [Unité de Traitement Accélérée (UTA)](apu1.md)
|
||||
* [Bus des composants](componentBus1.md)
|
||||
* [Processeur](cpu1.md)
|
||||
* [EEPROM](eeprom.md)
|
||||
* [Disquette](floppy.md)
|
||||
* [Disque dur](hdd1.md)
|
||||
* [Mémoire (RAM)](ram1.md)
|
||||
|
||||
## Fabrication
|
||||
* [Grog](acid.md)
|
||||
* [Unité de Logique Arithmétique (ULA)](alu.md)
|
||||
* [Touches directionnelles](arrowKeys.md)
|
||||
* [Groupe de boutons](buttonGroup.md)
|
||||
* [Base de carte](card.md)
|
||||
* [Plaque de circuit imprimé](circuitBoard.md)
|
||||
* [Unité de contrôle (UC)](controlUnit.md)
|
||||
* [Fil de coupe](cuttingWire.md)
|
||||
* [Disque](disk.md)
|
||||
* [Interweb](interweb.md)
|
||||
* [Puce électronique](chip1.md)
|
||||
* [Pavé numérique](numPad.md)
|
||||
* [Circuit imprimé](printedCircuitBoard.md)
|
||||
* [Plaque de circuit imprimé brute](rawCircuitBoard.md)
|
||||
* [Transistor](transistor.md)
|
||||
|
||||
## Assemblage / Impression
|
||||
* [Chamélium](chamelium.md)
|
||||
* [Cartouche d'encre](inkCartridge.md)
|
||||
* [Boitier de drone](droneCase1.md)
|
||||
* [Boitier de microcontrôleur](microcontrollerCase1.md)
|
||||
* [Boitier de tablette](tabletCase1.md)
|
||||
|
||||
## Autre
|
||||
* [Bottes de vol plané](hoverBoots.md)
|
||||
* [Nanomachines](nanomachines.md)
|
||||
@ -0,0 +1,5 @@
|
||||
# Cartouche d'encre
|
||||
|
||||
|
||||
|
||||
Les cartouches d'encre sont faites pour recharger le tampon encreur des [imprimantes 3D](../block/printer.md). Même s'il est possible de les recharger directement avec les pigments, c'est désordonné et inefficace. Il est vivement recommandé d'investir dans une véritable cartouche d'encre OpenComputers (TM), dès aujourd'hui ! (Annonce : elles pourraient coûter plus cher que l'imprimante elle-même, ou pas).
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user