Compare commits

...

385 Commits

Author SHA1 Message Date
Joachim Stolberg
8183b05675 Fix russian translation (https://github.com/joe7575/techage_modpack/pull/28) 2024-11-03 10:39:09 +01:00
Joachim Stolberg
009ea6f3fd
Merge pull request #185 from Niklp09/flowers
Don't spawn water plants on garden soil
2024-10-06 16:24:10 +02:00
Niklp
46b176805d
Don't spawn water plants on garden soil 2024-10-06 11:44:57 +02:00
Joachim Stolberg
d7be11a8aa Bug fix 2024-08-21 20:41:25 +02:00
Joachim Stolberg
8f255ec545 Fix bug 'TA2 boiler work without requiring boiler' 2024-07-21 20:57:03 +02:00
Joachim Stolberg
ec982b0de0 Remove the reset feature again 2024-07-18 06:44:51 +02:00
Joachim Stolberg
9a699a361f Add pre-assignment menu to the furnace 2024-07-14 22:26:54 +02:00
Joachim Stolberg
a1485b6eab Improve recording for move/fly/turn controllers 2024-07-13 11:41:19 +02:00
Joachim Stolberg
895b7895e6
Merge pull request #179 from Eternal-Study/Eternal-Study-patch-2
Add replacement to Electric Meter recipe
2024-07-11 18:19:07 +02:00
Eternal-Study
3453392c56
Add replacement to electricmeter recipe
Adds a replacement value to the electric meter recipe so as to return an empty spool to replace the gold wire.
2024-07-09 23:34:18 -04:00
Joachim Stolberg
25b087232d Fix injector bug 2024-07-08 18:56:47 +02:00
Joachim Stolberg
885d25a4a9
Merge pull request #178 from Niklp09/fix_flower_detection
Fix flowers detection when using ethereal
2024-07-03 21:19:27 +02:00
Niklp
abd945d5bc
Fix flowers detection when using ethereal 2024-07-03 20:53:06 +02:00
Joachim Stolberg
b1a338c8d4 Fix issue #175 (TA3 Furnace Does not implement replacements in recipes) 2024-06-30 14:00:34 +02:00
Joachim Stolberg
d7c31f9865 Fix bug #162 (Industrial Furnace Standby mode doesn't work as expected when connected to a pump) 2024-06-30 12:54:50 +02:00
Joachim Stolberg
c98b9a3b79
Merge pull request #176 from Eternal-Study/Eternal-Study-Salt-Patch
Water to Salt + River Water Reactor Recipe
2024-06-30 10:53:10 +02:00
Joachim Stolberg
923164c17c
Merge pull request #173 from Eternal-Study/Eternal-Study-patch-1
Add or minetest.registered_nodes[name] to Silo powder check.
2024-06-30 10:50:37 +02:00
Joachim Stolberg
ee3b19dd10
Merge pull request #172 from Niklp09/fix_deprecated_calls
Replace deprecated `meta:set_string(*, nil)` calls
2024-06-30 10:49:23 +02:00
Joachim Stolberg
11585b2f86
Merge pull request #171 from Niklp09/flb_list_del_if_empty
Don't serialize empty tables when saving flb lists
2024-06-30 10:47:50 +02:00
Eternal-Study
a3d77f5ff1
Add Salt.lua
Add new reactor recipes for salt and adds salt to powdered group.
2024-06-29 20:31:37 -04:00
Eternal-Study
46cd8b111d
Water to Salt + River Water Recipe
This pull requests adds a Water to River Water reactor recipe. If it detects a farming:salt node (as found in the Farming Redo mod) then it adds salt to the powder group, allowing it to be stored in silos, and changes the recipe to Water → Salt with River Water as a waste product.

It should be noted that issue [insert issue number here] must be resolved to implement this pull request, as otherwise nodes cannot be loaded into the silo, even if they are in the powder group. This pull request was tested with pull request [insert pull request number] implemented. Using another solution to issue [insert issue number here] may require updates to the pull request.

I release this code under the terms of AGPL v3, and transfer copyright to Joachim Stolberg.
2024-06-29 20:28:22 -04:00
Eternal-Study
0b84d478d7
Add or minetest.registered_nodes[name] to Silo powder check.
This pull request adds “or minetest.registered_nodes[name]” to the Silo powder check in line 131, permitting items in the powder group registered as nodes to be stored in the Silo. This improves interoperability with other mods by expanding the scope of items that can be stored, while still limiting it to the powder group.

It should be noted the powder check in lines 31-33 are noted affected by this pull request.

I release this code under the terms of AGPL v3, and transfer copyright to Joachim Stolberg.
2024-06-29 19:55:00 -04:00
Niklp
33c045fafb
Replace deprecated meta:set_string(*, nil) calls 2024-06-29 17:16:22 +02:00
Niklp
747bd7bfac
Don't serialize empty tables when saving flb lists 2024-06-29 16:07:49 +02:00
Joachim Stolberg
653e76c165 Add new button commands 2024-05-31 20:36:44 +02:00
Joachim Stolberg
a62f883d36 Improve command interface 2024-05-30 20:22:59 +02:00
Joachim Stolberg
bf5c5bb919 Enable recipes with input items with metadata as templates 2024-05-25 21:45:41 +02:00
Joachim Stolberg
9eb8e75efb Fix bug with injector and a full 8x2000 chest 2024-05-20 09:40:42 +02:00
Joachim Stolberg
1489fc26f3
Merge pull request #169 from Niklp09/flb_fs_list
Fix forceload block formspec list
2024-05-20 09:33:37 +02:00
Niklp
eed4d46d87
Fix forceload block formspec list 2024-05-20 00:13:13 +02:00
Joachim Stolberg
ac286776e3
Merge pull request #168 from Niklp09/nbox_low_power_box
Improve `techage:ta4_power_box` node_box
2024-05-01 11:06:10 +02:00
Niklp
c2c0686d07
Improve techage:ta4_power_box node_box 2024-04-30 21:43:48 +02:00
Joachim Stolberg
ab66660b32 Fix bug with detectors and full chests 2024-04-30 18:13:30 +02:00
Joachim Stolberg
5f0ddb211c Fix bug with detectors and full chests 2024-04-28 20:02:22 +02:00
Joachim Stolberg
bd7368a412 Fix bug with shop and injectors 2024-04-28 19:14:26 +02:00
Joachim Stolberg
a181f9524f Allow to move the TA4 terminal with the assembly tool (#165) 2024-04-20 15:44:56 +02:00
Joachim Stolberg
db28d18137
Merge pull request #166 from jfanjoy/feature/techpack-aluminum
add aluminum recipes for techpack_stairway items
2024-04-10 17:40:53 +02:00
John Fanjoy
368544046f add aluminum recipes for techpack_stairway items 2024-04-05 11:11:14 -04:00
Joachim Stolberg
064e9d0f26
Merge pull request #164 from Niklp09/replace_blanktile
Replace `techage_invisible.png` w/ engine provided `blank.png`
2024-04-03 18:38:09 +02:00
Joachim Stolberg
69cc7bff27
Merge pull request #163 from jfanjoy/feature/verify-forceload-blocks
adds a new chat command and column to forceload formspec
2024-04-03 18:37:54 +02:00
Niklp
65c6d0adbc
Replace techage_invisible.png w/ engine provided blank.png 2024-04-02 22:16:57 +02:00
John Fanjoy
6bfc943b01 adds a new chat command and column to forceload formspec 2024-04-01 16:41:02 -04:00
Joachim Stolberg
0b50136116 Fix bug #24 (Energy Storage respawn red gravel infinit) 2024-03-24 10:14:11 +01:00
Joachim Stolberg
aa7cdfba6e Error on load image on manual pt-BR #158 2024-03-24 10:02:00 +01:00
Joachim Stolberg
8b80ddab24
Merge pull request #159 from Niklp09/screwdriver_anvil
Allow TA3 screwdriver to get repaired by anvil
2024-03-24 09:48:46 +01:00
Niklp
66a3977c9f
Allow TA3 screwdriver to get repaired by anvil 2024-03-16 21:41:38 +01:00
Joachim Stolberg
77ee9928b7 Add translations and fix bug with growlight 2024-02-24 17:07:51 +01:00
Joachim Stolberg
ad2fa9d756 Add manual for pt-BR language 2024-02-04 21:39:16 +01:00
Joachim Stolberg
8ab2835141 Add reverse mode for ta5 pump 2024-01-21 12:36:44 +01:00
Joachim Stolberg
6b07399bf3 Fix issue #125 (Improve forceload formspec) 2024-01-21 11:55:48 +01:00
Joachim Stolberg
ccd017b665 Fix texture issoes 2024-01-21 11:55:48 +01:00
Joachim Stolberg
eea5c1a4ef Fix texture issoes 2024-01-21 11:55:48 +01:00
Joachim Stolberg
bb749c5eb2 Fix texture issoes 2024-01-21 11:55:48 +01:00
Joachim Stolberg
4e4445ff4e
Merge pull request #155 from Niklp09/master
Generate new randomseed after use
2023-12-30 11:32:32 +01:00
Niklp
a9c842897c Generate new randomseed after use 2023-12-28 22:00:12 +01:00
Joachim Stolberg
44720ca6ae Add some line breaks 2023-12-26 17:05:57 +01:00
Joachim Stolberg
63310ed33d Fix assembly tool bug with non-empty chests 2023-12-25 21:55:45 +01:00
Joachim Stolberg
7bb16c6a73 Typo 2023-11-11 18:58:34 +01:00
Joachim Stolberg
fad059c1bf Fix #151 (crash on 'test X') 2023-11-11 18:38:08 +01:00
Joachim Stolberg
11c3dea912 Techage v1.18 2023-11-05 13:11:32 +01:00
Joachim Stolberg
4e77cfab70
Merge pull request #150 from alwayshopeless/patch-2
Water mill river water bug fix
2023-11-05 00:43:07 +01:00
alwayshopeless
a5634c7a75
Water mill river water bug fix 2023-11-04 13:44:04 +02:00
Joachim Stolberg
f5becb1eb8 Fix #148 (Collider documentation is hard to follow) 2023-11-01 18:17:18 +01:00
Joachim Stolberg
2a157dc825 Fix #148 (Collider documentation is hard to follow) by means of:
- Remove the gas connection on the back of the magnets
- Add code to turn legacy magnets to the right direction
- Improve manual
2023-11-01 18:12:00 +01:00
Joachim Stolberg
2c16b9d01f Fix #147 (Sea level might not be y==1 for water inlets) 2023-11-01 18:10:58 +01:00
Joachim Stolberg
c81f62fd39 Fix concentrator blocking bug 2023-10-22 16:33:09 +02:00
Joachim Stolberg
6042a9d30a Allow further types of cobblestone for the coalburner 2023-10-22 11:25:14 +02:00
Joachim Stolberg
4ed5d7494f Improve description 2023-10-14 14:24:44 +02:00
Joachim Stolberg
d0e9d0b656 Improve description 2023-10-13 13:50:25 +02:00
Joachim Stolberg
1838507521 Fix burn time issue 2023-10-13 13:49:57 +02:00
Joachim Stolberg
7a99d7c0ad Add function to allow to disable a block from being removed by the assembly tool 2023-09-29 19:40:25 +02:00
Joachim Stolberg
a347405150 Add storesize command 2023-09-27 19:27:49 +02:00
Joachim Stolberg
5b94e40243
Merge pull request #146 from Niklp09/creative_check
Use proper player creative check
2023-09-24 10:01:11 +02:00
Niklp09
ae9458aa45 Use proper player creative check 2023-09-23 21:54:10 +02:00
Joachim Stolberg
bc6697a8cc Optimize recipe command 2023-09-17 18:47:48 +02:00
Joachim Stolberg
cb11941f30
Merge pull request #144 from Niklp09/converter_fix
Fix converter stores mesecon signals
2023-09-17 13:48:20 +02:00
Niklp09
ae52a9242d Fix converter stores mesecon signals 2023-09-17 10:26:12 +02:00
Joachim Stolberg
908678e840 Add new assembly tool 2023-09-16 21:03:46 +02:00
Joachim Stolberg
5a0aadc063 Add flush command 2023-09-16 12:04:43 +02:00
Joachim Stolberg
18bd475a5d Add flush command 2023-09-16 12:04:17 +02:00
Joachim Stolberg
38946d6d84 Add flush command 2023-09-16 12:03:57 +02:00
Joachim Stolberg
957466f2e1 Unify wrench menu for generators 2023-09-05 21:26:15 +02:00
Joachim Stolberg
b32d22b0c8 Add arrow on the bottom 2023-09-05 21:26:15 +02:00
Joachim Stolberg
4f4c370358 Add Beduino command interface 2023-09-05 21:26:15 +02:00
Joachim Stolberg
a946658b3b
Merge pull request #143 from Niklp09/tr_fix
Escape equal sign in german translation
2023-09-01 20:03:21 +02:00
Niklp09
73fadb4fc3 Escape equal sign in german translation 2023-09-01 11:48:24 +02:00
Joachim Stolberg
7871b81c2a Allow rotation with a screwdriver 2023-08-28 17:03:17 +02:00
Joachim Stolberg
14440f0cad Improve manual 2023-08-28 10:35:55 +02:00
Joachim Stolberg
aee918d025 Improve TA2 clutch 2023-08-27 20:18:55 +02:00
Joachim Stolberg
9111d7287c Add TA2 clutch 2023-08-26 21:27:56 +02:00
Joachim Stolberg
92039b3a83 Add TA2 clutch 2023-08-26 21:26:22 +02:00
Joachim Stolberg
ae8d2d3d09 Add TA2 clutch 2023-08-26 19:37:03 +02:00
Joachim Stolberg
c7ac277d40 Add TA2 clutch 2023-08-26 17:55:12 +02:00
Joachim Stolberg
b258057317 Add generator menu to TA5 generator 2023-08-26 10:25:18 +02:00
Joachim Stolberg
a740837b30
Merge pull request #142 from debiankaios/inv_name_prefix
Added inv_name_prefix
2023-08-24 17:50:08 +02:00
debiankaios
fffc542ac6
Added inv_name_prefix 2023-08-23 21:26:53 +02:00
Joachim Stolberg
4a5ad68054 format issue 2023-08-21 20:32:53 +02:00
Joachim Stolberg
d6157087f1 Adapt to lcdlib 1.03 2023-08-20 21:46:31 +02:00
Joachim Stolberg
2dc3f24f1c Fix manual issues, increase version to v1.17 2023-08-20 14:22:40 +02:00
Joachim Stolberg
6b77916afa Fix minor bugs and adapt mod to the new lcdlib mod 2023-08-19 17:58:58 +02:00
Joachim Stolberg
56b8e2bef6 Fix image format bug 2023-08-19 15:26:07 +02:00
Joachim Stolberg
6189fde452 Fix texture issues 2023-08-18 17:53:48 +02:00
Joachim Stolberg
56197d229b Add support for doclib 2023-08-18 17:30:55 +02:00
Joachim Stolberg
366913ac58 Fix LICENCSE file bug 2023-07-31 21:05:17 +02:00
Joachim Stolberg
e12ba852cf Fix texture bug 2023-07-20 18:59:24 +02:00
Joachim Stolberg
f737be9a38 Remove needless code 2023-07-20 18:57:40 +02:00
Joachim Stolberg
7947d23719
Merge pull request #138 from Niklp09/quarry_log
log position of coroutine errors
2023-07-20 18:43:53 +02:00
Niklp09
0f8846d6f6 log position of coroutine errors 2023-07-15 13:09:29 +02:00
Joachim Stolberg
ec34c87b97 Add digging depth 7 2023-07-02 19:23:29 +02:00
Joachim Stolberg
a2cba47c63
Merge pull request #136 from realmicu/master
Add beduino support for TA3 repeater
2023-07-02 18:39:39 +02:00
Michal Cieslakiewicz
cf3b525529 Add beduino support for TA3 repeater 2023-07-01 21:26:04 +02:00
Joachim Stolberg
f68260310b v1.16 2023-06-30 15:12:36 +02:00
Joachim Stolberg
d85de971a7 Add TA4 node detector 2023-06-30 14:30:15 +02:00
Joachim Stolberg
cbd8b0ca52 Add wrench menu to TA3 button 2023-06-30 10:25:50 +02:00
Joachim Stolberg
39d13286d9 Add arrows to the pump bottom and allow to turn the pump with the Techage Screwdriver 2023-06-30 10:15:11 +02:00
Joachim Stolberg
5b0be32db3 Fix bug with configurred TA4 chest and TA5 teleport tubes 2023-06-30 09:57:08 +02:00
Joachim Stolberg
4206875f23 Fix the possible server crash error 2023-06-30 09:56:13 +02:00
Joachim Stolberg
3b51e1d557 Fix water placement issue 2023-06-24 09:47:17 +02:00
Joachim Stolberg
e262cccdfe Undo last bug fix 2023-06-24 08:03:38 +02:00
Joachim Stolberg
b1efedb55f Improve gaze sensor 2023-06-23 21:54:39 +02:00
Joachim Stolberg
356e8310d8 Fix typo 2023-06-23 15:31:50 +02:00
Joachim Stolberg
780b39d23c Enable the use as elevator winch 2023-06-23 15:31:20 +02:00
Joachim Stolberg
af5038387a Fix typo 2023-06-23 15:30:40 +02:00
Joachim Stolberg
99645642c2 Add dirt blocks to the list of simple nodes 2023-06-20 21:43:56 +02:00
Joachim Stolberg
f9035e4aea Fix quarry depth bug 2023-06-20 21:41:30 +02:00
Joachim Stolberg
f602a502bb Add chat message if block can't be moved 2023-06-13 19:23:44 +02:00
Joachim Stolberg
f7863333d5 Prevent triggering when player has open-end wrench in hand 2023-06-10 16:59:46 +02:00
Joachim Stolberg
947a31f350 Prevent triggering when player has open-end wrench in hand 2023-06-10 16:53:09 +02:00
Joachim Stolberg
4d33f5f034 Improve the behaviour 2023-06-10 16:49:15 +02:00
Joachim Stolberg
d6be0812c4 Add flip-flop 2023-06-09 16:31:22 +02:00
Joachim Stolberg
9210bce637 Add TA3 Command Converter and TA4 Gaze Sensor 2023-06-09 15:43:48 +02:00
Joachim Stolberg
e9ddfee834 Fix flycontroller bug #134 2023-06-09 13:26:54 +02:00
Joachim Stolberg
a7449c86ab Add TA3 Command Converter and TA4 Gaze Sensor 2023-06-08 21:41:27 +02:00
Joachim Stolberg
7872915be3 Add TA3 Command Converter and TA4 Gaze Sensor 2023-06-08 21:16:22 +02:00
Joachim Stolberg
d758751ee0 Add TA3 Command Converter and TA4 Gaze Sensor 2023-06-08 21:09:27 +02:00
Joachim Stolberg
4b164afca3 Change event behavior 2023-05-29 16:52:07 +02:00
Joachim Stolberg
84971f05b3 Fix node state bug 2023-05-29 16:51:07 +02:00
Joachim Stolberg
97936102c3 Add 'current' command to the TA4 Electric Meter 2023-05-21 17:54:38 +02:00
Joachim Stolberg
301d20aaf1 Fix some typos (Thanks to Gorm) 2023-05-20 13:49:32 +02:00
Joachim Stolberg
6a92a72e14 Fix runtime error, occuring when top of a TA5 heat exchanger is removed 2023-05-20 13:36:14 +02:00
Joachim Stolberg
1e007f2f0e Add hint to the water consumption of the steam engine 2023-05-18 19:58:00 +02:00
Joachim Stolberg
9d48746093 Make manual corrections 2023-05-18 19:28:41 +02:00
Joachim Stolberg
3669ef0f96 Improve fusion reactor checks 2023-05-18 18:32:08 +02:00
Joachim Stolberg
0f7814034d Add energy storage charge detector 2023-05-17 22:02:17 +02:00
Joachim Stolberg
dac5872e8c Fix issue with dst inventory 2023-05-17 22:02:17 +02:00
Joachim Stolberg
3cc2a01779 Fix bug with pump limit via commands 2023-05-17 22:02:16 +02:00
Joachim Stolberg
11944f7aba
Update ta4_lua_controller_EN.md 2023-05-15 20:54:14 +02:00
Joachim Stolberg
14136ff363
Update ta4_lua_controller_EN.md
Fix link bug
2023-05-15 20:53:50 +02:00
Joachim Stolberg
37a3e1398e Add some num/string corrections 2023-05-15 20:51:04 +02:00
Joachim Stolberg
240ab79203 Fix typo 2023-05-14 18:01:27 +02:00
Joachim Stolberg
6e2ed8071b Add lua example for TA4 4x Button 2023-05-14 15:41:49 +02:00
Joachim Stolberg
d5c63a8e56 Fix controller stop command bug 2023-05-14 15:40:45 +02:00
Joachim Stolberg
d8caf09cf7 Reduce the waiting time for experience points 2023-05-14 15:40:04 +02:00
Joachim Stolberg
125e5ad689 Reduce the waiting time for experience points 2023-05-14 15:39:48 +02:00
Joachim Stolberg
2d39171b1f Fix minor manual issues 2023-05-09 18:40:37 +02:00
Joachim Stolberg
5b5d5b57ac Fix minor manual issues 2023-05-06 19:11:12 +02:00
Joachim Stolberg
d2cd7fff27 Change the recipe to prevent an infinite cobble source 2023-05-06 19:10:39 +02:00
Joachim Stolberg
6ee7306e90 Fix the bug with hyperloop dependency 2023-05-06 18:40:15 +02:00
Joachim Stolberg
65852f2035 Set version to 1.15 2023-05-05 21:55:20 +02:00
Joachim Stolberg
a7cbf6924d Add further energy storage sizes 2023-05-05 21:41:23 +02:00
Joachim Stolberg
a93ef1db2c Add bucket register function 2023-05-05 20:58:04 +02:00
Joachim Stolberg
1c86092894 Add hyperloop chest only if the hyperloop mod is available 2023-05-05 19:41:16 +02:00
Joachim Stolberg
dabccff9b0 Add missing 'minetest.formspec_escape' (#131) 2023-04-30 12:56:08 +02:00
Joachim Stolberg
9de42a5a66 Fix bug "Trouble with flycontroller #130" 2023-04-27 19:43:40 +02:00
Joachim Stolberg
86ff66684c
Merge pull request #129 from orwell96/patch-1
Add optional dependency on farming mod
2023-04-25 18:59:33 +02:00
orwell96
9ebb3a9f6f
Add optional dependency on farming mod
While trying out techage_modpack, I noticed that the TA1 mill doesn't have any recipes registered. I could eventually track it down to the following:
- At load time, if techage gets loaded before farming, the registration for the wheat recipes (in the mill) is skipped
- Changing the global_exists() to a get_modpack() doesn't remedy the issue as add_grinder_recipe() checks for item existence
Soft-depending on farming remedies the issue and the mill works normally.
2023-04-24 22:20:45 +02:00
Joachim Stolberg
dbae9bd8e4
Merge pull request #127 from Niklp09/ffs
fix forceload formspec receiver
2023-04-23 11:30:35 +02:00
Niklp09
7bdd00c019 fix forceload formspec receiver 2023-04-18 13:11:53 +02:00
Joachim Stolberg
09e48c4084 Update version to v1.14 2023-04-16 15:12:55 +02:00
Joachim Stolberg
fc80a90ff2 Add API manual 2023-04-16 15:08:05 +02:00
Joachim Stolberg
05670352c6 Add API function register_ore_for_gravelsieve 2023-04-16 15:07:29 +02:00
Joachim Stolberg
9e1ae22bf4 Add support for the game Asuna (#126) 2023-04-13 20:20:58 +02:00
Joachim Stolberg
9e226d6d8a Remove teleport mode for move controller 2023-04-11 12:49:56 +02:00
Joachim Stolberg
66a4c3ae7f Fix manual issue #123 2023-04-11 11:05:15 +02:00
Joachim Stolberg
a3079dae78
Merge pull request #124 from Niklp09/drops
fix unknown item drops
2023-04-11 11:00:42 +02:00
Niklp09
f0c0ee3d75 fix unknown item drops 2023-04-11 10:44:21 +02:00
Joachim Stolberg
109c5c371e Fix keep node number issue 2023-04-10 16:52:24 +02:00
Joachim Stolberg
a932296420 Add "Teleport mode" to ta4 move and ta5 fly controller 2023-04-10 16:32:41 +02:00
Joachim Stolberg
b2ad9f3058 Fix use of deprecated field name in some tile definitions #12 2023-04-07 10:51:33 +02:00
Joachim Stolberg
bf33f47b2c Fix texture flipping issues 2023-04-03 19:39:39 +02:00
Joachim Stolberg
7051da903e v1.12 2023-04-01 19:19:53 +02:00
Joachim Stolberg
e5fc8a4b8a Add version command 2023-04-01 19:19:29 +02:00
Joachim Stolberg
062b3f5fef fix overload bug, fix missing dominant 'on' issue 2023-04-01 19:10:14 +02:00
Joachim Stolberg
2e24ccbdcd Disable inventory access on client side due to minetest core issues 2023-04-01 19:09:04 +02:00
Joachim Stolberg
1fcadc9ff7 Fix bug with reset button 2023-03-28 18:34:54 +02:00
Joachim Stolberg
c3a492cb89 Add craftable and invisible move block 2023-03-28 18:33:43 +02:00
Joachim Stolberg
6159ccaa96 Add craftable and invisible move block 2023-03-21 20:00:26 +01:00
Joachim Stolberg
d92c2a7b91 Fix ta4 pusher counting bug 2023-03-20 20:09:58 +01:00
Joachim Stolberg
774d0d2e42 Add running state 2023-03-19 17:05:03 +01:00
Joachim Stolberg
f84b040346 Increase player inventory to 8x4 for the filler 2023-03-19 11:53:27 +01:00
Joachim Stolberg
15e021e2ed fix bug with ta3 node_detector and wielded_light nodes 2023-03-19 11:46:23 +01:00
Joachim Stolberg
279b876087
Merge pull request #120 from Niklp09/aliases
add an option to disable stair aliases
2023-03-19 10:52:22 +01:00
Niklp09
45357e2980 add an option to disable stair aliases 2023-03-13 14:11:08 +01:00
Joachim Stolberg
41b82454c4 Improve transformer and electricmeter:
Transformer:
- add wrench menu for 'max. power passed through'
- Increase max. power passed through from 100 to 300 ku

Electricmeter:
- add wrench menu for 'max. power passed through' and 'power countdown'
- add commands to read the countdown value (Lua and Beduino controller)
2023-03-05 22:06:48 +01:00
Joachim Stolberg
37f6462673 Improve transformer and electricmeter 2023-03-05 21:44:35 +01:00
Joachim Stolberg
e95949ae04 Update history 2023-03-05 11:51:03 +01:00
Joachim Stolberg
6e193f57ae Fix paramtype/use_texture_alpha issue 2023-03-05 11:39:01 +01:00
Joachim Stolberg
b40447ed95 fix issue #119 (Possible Bug in techage:ta4_display) 2023-03-05 11:34:34 +01:00
Joachim Stolberg
57f5a3594b Reduce the number of necessary exp points 2023-02-28 21:12:57 +01:00
Joachim Stolberg
4c3e73b3f9 Try to fix kernel crashes 2023-02-27 19:57:56 +01:00
Joachim Stolberg
460cc7eefd Fix another chest chain bug 2023-02-27 19:57:36 +01:00
Joachim Stolberg
1a861c7f15 Try to fix kernel crashes 2023-02-27 19:57:28 +01:00
Joachim Stolberg
71a024649a Try to fix kernel crashes 2023-02-27 19:57:24 +01:00
Joachim Stolberg
93c004132f Rework doorcontroller 2023-02-26 21:01:50 +01:00
Joachim Stolberg
30b0a51209 Rework doorcontroller 2023-02-26 19:56:14 +01:00
Joachim Stolberg
82d9d6de55 Increase tank cart storage size to 200 2023-02-20 20:57:42 +01:00
Joachim Stolberg
e068a39c4d Fix paramtype/use_texture_alphaissue 2023-02-20 20:57:07 +01:00
Joachim Stolberg
2826423e5b Add command 'load' to the TA4 power terminal 2023-02-19 21:29:07 +01:00
Joachim Stolberg
a53ab04ca2 Add beduino tank commands 2023-02-19 19:23:38 +01:00
Joachim Stolberg
354dcf2684 Fix command on/off bug 2023-02-19 19:07:28 +01:00
Joachim Stolberg
6d9c9bb51f Improve power terminal 2023-02-19 16:47:06 +01:00
Joachim Stolberg
66937f5743 Fix power consumption bug for a stopped collider 2023-02-19 15:11:43 +01:00
Joachim Stolberg
77181cbc3b Fix electrolyzer formspec bug 2023-02-19 10:54:13 +01:00
Joachim Stolberg
633e1e987d
Merge pull request #118 from Niklp09/autocrafter
fix sigsegv's due autocrafter
2023-02-16 16:53:34 +01:00
Niklp09
c7c61d05fb fix sigsegv's due autocrafter 2023-02-15 18:17:00 +01:00
Joachim Stolberg
68a8555825 Fix doser goes blocked bug 2023-02-12 21:30:12 +01:00
Joachim Stolberg
83b2bd483f Add missing translations 2023-02-12 17:56:38 +01:00
Joachim Stolberg
d82ae0c86e Add Rack and pinion node 2023-02-12 17:53:46 +01:00
Joachim Stolberg
b8009dd2ab Add Rack and pinion node 2023-02-12 17:46:03 +01:00
Joachim Stolberg
b759386016 Expand sequencer wrench menu 2023-02-12 11:53:09 +01:00
Joachim Stolberg
228b2d39cc Expand sequencer wrench menu 2023-02-12 11:50:43 +01:00
Joachim Stolberg
8fcd4ef70b Expand sequencer wrench menu 2023-02-12 11:50:31 +01:00
Joachim Stolberg
50d9816fa7 Expand sequencer wrench menu 2023-02-12 11:50:21 +01:00
Joachim Stolberg
7ac25a098d Add cement block to the saw 2023-02-11 18:41:21 +01:00
Joachim Stolberg
f8e47ed4b1 Allow to move objects 'without' a move block 2023-02-11 18:00:27 +01:00
Joachim Stolberg
4a09dc785f Add empty_spool as fab output 2023-02-11 17:15:46 +01:00
Joachim Stolberg
b85e325cd5 Fix doser goes blocked bug 2023-02-11 11:45:04 +01:00
Joachim Stolberg
8c5adfdd50 Flip texture (issue #116) 2023-02-08 18:33:54 +01:00
Joachim Stolberg
f141588818 Fix bug 'nvmstack' (a nil value) 2023-02-07 20:04:59 +01:00
Joachim Stolberg
078069baf6 Fix movecontroller bug when carts are running in both directions 2023-02-06 17:42:25 +01:00
Joachim Stolberg
07fcfafedf Remove handover description 2023-02-06 16:33:23 +01:00
Joachim Stolberg
c95e3e7b50 Accept mincart carts for the move controller 2023-02-05 19:34:08 +01:00
Joachim Stolberg
46d2ae91aa Accept mincart carts for the move controller 2023-02-05 18:14:01 +01:00
Joachim Stolberg
39cbeea15e Update to v1.10 2023-02-04 15:43:26 +01:00
Joachim Stolberg
7cfc5c3840 Improve flycontroller, remove handover for movecontroller 2023-02-04 15:32:05 +01:00
Joachim Stolberg
baea3f137f Fix 2 flycontroller bugs 2023-02-02 19:22:37 +01:00
Joachim Stolberg
14f7c8718c Fast fix for #115: bad argument #1 to 'pairs' (table expected, got nil) 2023-01-29 16:47:07 +01:00
Joachim Stolberg
8bb62a4abc Fix the 'lpos1 (a nil value)' bug 2023-01-28 11:12:04 +01:00
Joachim Stolberg
9a03cd86d2 Fix node number register issue 2023-01-27 17:24:05 +01:00
Joachim Stolberg
d8d655e516 Use repairkit to reactivate broken techage nodes 2023-01-24 21:24:14 +01:00
Joachim Stolberg
436fec17d2 Fix beduino command issue 2023-01-24 19:10:31 +01:00
Joachim Stolberg
2d71d06dc5 Fix bug #107 (Blocks not rendering properly) 2023-01-23 17:17:37 +01:00
Joachim Stolberg
80d4edb99c Update manual 2023-01-23 17:14:52 +01:00
Joachim Stolberg
11f4cf6eeb Rename to color lamp 2023-01-23 17:12:10 +01:00
Joachim Stolberg
29a2e404ed Rename to color lamp 2023-01-23 17:11:44 +01:00
Joachim Stolberg
aa466d3827 Rename to color lamp 2023-01-23 17:10:52 +01:00
Joachim Stolberg
8592d65589 Rename to color lamp 2023-01-23 17:09:42 +01:00
Joachim Stolberg
ab9e7040d5 Add state command 2023-01-23 17:07:45 +01:00
Joachim Stolberg
39b7ca719d Fix bakedclay recipe conflict 2023-01-14 20:49:48 +01:00
Joachim Stolberg
26558ce1eb Fix some beduino command issues 2023-01-08 14:00:47 +01:00
Joachim Stolberg
71d0d6f012 Fix unremovable ta4_chest_dummy bug 2023-01-08 14:00:47 +01:00
Joachim Stolberg
a88a07e421
Merge pull request #110 from Niklp09/dump
disable flowers table dump
2023-01-07 17:45:44 +01:00
Niklp09
c858c56ec9 disable flowers table dump 2023-01-07 15:24:08 +01:00
Joachim Stolberg
b92e746e18 Add countdown mode to TA4 Detector 2023-01-05 12:57:26 +01:00
Joachim Stolberg
7b2f10e915 Add some missing recipes 2023-01-05 09:52:09 +01:00
Joachim Stolberg
c042115cbb
Merge pull request #108 from Niklp09/growlight
glowlight: register flowers only once
2023-01-04 22:34:21 +01:00
Joachim Stolberg
51c71d499f Adapt to new beduino and minecart versions 2023-01-04 22:28:32 +01:00
Niklp09
4d73d3fdf2 glowlight: register flowers only once 2023-01-04 13:38:08 +01:00
Joachim Stolberg
638993b49b Fix sound bug 2023-01-04 10:12:20 +01:00
Joachim Stolberg
b59567aab1 Replace blanks with tabs 2023-01-03 17:24:27 +01:00
Joachim Stolberg
8b1a4f8dcf Add missing recipe 2023-01-03 17:23:21 +01:00
Joachim Stolberg
74593fa150 Fix sound bug 2023-01-03 17:22:57 +01:00
Joachim Stolberg
c69cb294a0 Add wafer recipe with 'mesecons_materials:silicon' 2022-12-31 10:49:25 +01:00
Joachim Stolberg
c1645fc9b9 Add TA5 AI Chip II to the manual 2022-12-30 19:05:30 +01:00
Joachim Stolberg
d78004cef3 Fix movecontroller wrench menu bug 2022-12-11 09:49:00 +01:00
Joachim Stolberg
b9072c7940 Improve chemical reactor description 2022-12-10 13:47:09 +01:00
Joachim Stolberg
4cb7ffe718 Improve player detector wrench menu 2022-12-10 12:38:15 +01:00
Joachim Stolberg
ac01df763d Fix 'count' command bug: default value is 0 again 2022-12-10 11:09:27 +01:00
Joachim Stolberg
dc899e1bd1 Allow moving blocks through unloaded areas 2022-12-09 21:19:22 +01:00
Joachim Stolberg
c6afb4a173 Remove EOL blanks 2022-12-09 21:17:21 +01:00
Joachim Stolberg
446de79704 Allow moving blocks through unloaded areas 2022-12-09 21:17:01 +01:00
Joachim Stolberg
902fabd148 Allow moving blocks through unloaded areas 2022-12-06 18:43:10 +01:00
Joachim Stolberg
29e542eb74 Add wrench menu to configure search radius 2022-12-02 20:30:00 +01:00
Joachim Stolberg
2b541d0197 Place unloaded flying blocks to dest pos 2022-12-02 20:29:38 +01:00
Joachim Stolberg
c83da97df5 Add wrench menu to configure search radius 2022-12-02 20:24:19 +01:00
Joachim Stolberg
7a4a446d82 Furnace: Don't use items filled from the top as fuel 2022-11-21 21:50:37 +01:00
Joachim Stolberg
c98258238b Manual improvements for the move controller 2022-11-19 21:44:38 +01:00
Joachim Stolberg
c47c6aa54c Make a use for cotton seeds #104 2022-11-19 21:20:29 +01:00
Joachim Stolberg
fca2faaeef
Merge pull request #102 from Niklp09/mvps2
fix broken mesecons detection
2022-11-16 12:54:41 +01:00
Niklp
c127297254
fix broken mesecons detection 2022-11-14 20:00:00 +01:00
Joachim Stolberg
f14e93e17a Fix bug with TA1 hammer used by pipeworks nodebreaker 2022-11-13 12:01:58 +01:00
Joachim Stolberg
99b2f8f0c5 Fix bug with TA1 hammer used by pipeworks nodebreaker 2022-11-07 21:38:18 +01:00
Joachim Stolberg
41c4492ca6
Merge pull request #99 from Niklp09/mvps
register mvps stopper for complex techage nodes
2022-11-06 11:39:49 +01:00
Niklp
554d79b740
use global_exist to check if mesecons is available 2022-11-06 11:19:15 +01:00
Niklp09
75dca89737 register mvps stopper for complex techage nodes 2022-11-05 14:54:00 +01:00
Joachim Stolberg
18d06994bc
Merge pull request #98 from Niklp09/glow_gravel
add not in creative inv group to grow gravel
2022-11-01 20:28:39 +01:00
Joachim Stolberg
f70c58d356 Fix hammer bauxite bug 2022-10-29 20:51:33 +02:00
Joachim Stolberg
f9a582af5e fix server crash 2022-10-29 20:50:06 +02:00
Niklp
e849077e52
add not in creative inv group to grow gravel 2022-10-23 16:25:16 +02:00
Joachim Stolberg
416126f80c fix mesecons_materials bug 2022-10-18 16:39:26 +02:00
Joachim Stolberg
2dedba04b1 add cracking recipe for isobutane 2022-10-18 14:12:51 +02:00
Joachim Stolberg
7e7642a96f
Merge pull request #96 from Niklp09/ethereal
grind ethereal leaves to leave powder
2022-10-12 17:25:16 +02:00
Niklp
6bebc47f84
grind ethereal leaves to leave powder 2022-10-01 18:04:55 +02:00
Joachim Stolberg
6cc1f75d15 Improve manual, fix bug in electrolyzer menu description 2022-10-01 15:49:28 +02:00
Joachim Stolberg
4469dd128c Add 'on button' mode to the button 2022-09-18 11:53:51 +02:00
Joachim Stolberg
742fc51dc0 Add wrench menu to ta4_sequencer 2022-09-17 19:30:56 +02:00
Joachim Stolberg
90f4e4da3f Add wrench menu to ta4_sequencer 2022-09-17 18:51:26 +02:00
Joachim Stolberg
0305ab20f4 Fix pusher and chest bugs 2022-09-17 16:21:57 +02:00
Joachim Stolberg
e2f72ca57e Improve TA4 button wrench menu 2022-09-16 19:30:49 +02:00
Joachim Stolberg
d3126bff70 Fix pusher bug 2022-09-14 18:24:49 +02:00
Joachim Stolberg
79cf2ba7af Fix TA4 pusher and flycontroller bugs 2022-09-13 21:13:09 +02:00
Joachim Stolberg
3ce0af9a3d Fix signallamp color bug 2022-09-12 17:15:51 +02:00
Joachim Stolberg
c57724dbd0 Add command to ta4_doser to change recipe, add pusher/hopper support for ta4_reactor inventory 2022-09-11 14:32:59 +02:00
Joachim Stolberg
2ea430d054 Update networks dependency 2022-09-10 20:46:25 +02:00
Joachim Stolberg
9f38cef427 Improve repairkit for pumps 2022-09-10 20:42:31 +02:00
Joachim Stolberg
680f411e04 Add chat command ta_color 2022-09-10 18:13:20 +02:00
Joachim Stolberg
70febea204 Add chat command ta_color 2022-09-10 18:06:41 +02:00
Joachim Stolberg
4f0cacb224 Add new signal lamp with color commands 2022-09-10 16:04:45 +02:00
Joachim Stolberg
4702f46b07 Fix issue #93 (slow down TA1 gravel sieve) 2022-09-10 16:03:42 +02:00
Joachim Stolberg
4378e42ef1 Fix issue #93 (slow down TA1 gravel sieve) 2022-09-10 15:51:43 +02:00
Joachim Stolberg
2b43e8a913 Remove test blocks 2022-09-04 21:49:00 +02:00
Joachim Stolberg
713f3675ab Fix move command bug in move controller 2022-09-04 20:05:18 +02:00
Joachim Stolberg
69aac18dc5 Add Flow Limiter mode to TA4 pusher 2022-09-04 18:25:03 +02:00
Joachim Stolberg
873a51e3db Add Flow Limiter mode to TA4 pusher 2022-09-04 18:05:37 +02:00
Joachim Stolberg
15a4765b6f Add Flow Limiter mode to TA4 pump 2022-09-03 19:22:43 +02:00
Joachim Stolberg
3426712006 Change behavior of push_items function 2022-09-02 21:12:25 +02:00
Joachim Stolberg
1182912724 Improve readme 2022-08-19 21:39:56 +02:00
Joachim Stolberg
e997fe797d Add distance check to ta4 movecontroller 2022-08-18 18:09:07 +02:00
Joachim Stolberg
ede42eefbd Add distance check to ta4 movecontroller 2022-08-18 18:06:55 +02:00
Joachim Stolberg
22495ad741 Improve readme 2022-08-18 14:38:10 +02:00
Joachim Stolberg
65e951a7ee Fix issue #90 (Disappearing tank contents) 2022-08-18 14:29:33 +02:00
Joachim Stolberg
25d5ca0a02 Fix issue #8 (techage uses 'mesecon' as a dependency instead of 'mesecons') 2022-08-18 14:27:02 +02:00
Joachim Stolberg
16c152e475
Merge pull request #89 from asl97/patch-1
Move box under textarea, fixes overlay blocking scrollbar
2022-08-16 15:40:16 +02:00
asl97
71380ffdf8
Move box under textarea, fixes overlay blocking scrollbar
Fixes #87
2022-08-12 16:31:14 +08:00
Joachim Stolberg
0c3f1f56a4 Fix node state request bug 2022-08-09 21:15:28 +02:00
Joachim Stolberg
c78ea7eb66 Fix ICTA controller bugs 2022-08-09 20:27:33 +02:00
Joachim Stolberg
c0a11e2477 Fix use_texture_alpha issues 2022-08-07 16:03:33 +02:00
Joachim Stolberg
1652b154b4 Add testblock 2022-08-05 17:48:47 +02:00
Joachim Stolberg
493422fb1b Fix minor issues 2022-08-03 22:19:46 +02:00
Joachim Stolberg
d61517ee3c Change beduino/move_controller limits 2022-08-02 13:28:32 +02:00
Joachim Stolberg
87dfe8e651 Fix use_texture_alpha issues 2022-07-11 20:20:00 +02:00
Joachim Stolberg
79ad815ed6 Fix use_texture_alpha issues 2022-07-11 20:16:23 +02:00
Joachim Stolberg
1219deb83d Fix beduino.counting bug 2022-07-08 22:24:37 +02:00
Joachim Stolberg
904d6559d3 Fix ICTA controller bug 2022-07-08 20:59:22 +02:00
Joachim Stolberg
7082e1ab0d Add time & name commands to the TA4 button 2022-07-03 16:07:38 +02:00
Joachim Stolberg
df6a526a99 Fix door controller issue 2022-06-25 10:28:32 +02:00
Joachim Stolberg
137e61b6ce Fix division with zero bug 2022-06-24 20:59:08 +02:00
Joachim Stolberg
b936024113 Minor improvements 2022-06-23 20:36:36 +02:00
Joachim Stolberg
998689aafd Fiy beduino command bug 2022-06-21 20:21:16 +02:00
Joachim Stolberg
3a593ff56f Add new config & get commands 2022-06-12 18:35:32 +02:00
Joachim Stolberg
ce839fead3 Add new config & get commands 2022-06-12 18:35:06 +02:00
Joachim Stolberg
07a7f2fffa Fix chest chain bug 2022-06-12 18:34:06 +02:00
Joachim Stolberg
e69e30bad8 Fix bug so that blocks don't respawn after an on/off command 2022-06-12 11:02:05 +02:00
Joachim Stolberg
5056a4a4fb Add 'get name' command to the door controller 2022-06-10 11:48:59 +02:00
Joachim Stolberg
f7d12dd79a Implement fly/door controller improvements 2022-06-10 10:59:59 +02:00
Joachim Stolberg
deb9678b54 Add key/value store for the beduino controller 2022-06-09 21:46:56 +02:00
Joachim Stolberg
6a71892799 Fix beduino command bugs 2022-06-09 12:59:17 +02:00
Joachim Stolberg
ff7e30a1c0 Improve TA4 movecontroller 2022-06-08 18:14:42 +02:00
Joachim Stolberg
acb54d7e8d Improve TA3 doorcontroller2 2022-06-07 22:32:03 +02:00
Joachim Stolberg
e2bd472408 Minor improvements 2022-06-07 19:14:43 +02:00
Joachim Stolberg
7bc1221249 Add support for beduino commands 2022-06-06 20:43:52 +02:00
Joachim Stolberg
24e91edc7e Add support for beduino commands 2022-06-06 20:39:55 +02:00
Joachim Stolberg
a0b637e4e9 Add support for beduino commands 2022-06-06 15:59:12 +02:00
Joachim Stolberg
abac1cce98 Add support for beduino commands 2022-06-05 21:23:17 +02:00
Joachim Stolberg
b6eeef358a Add support for beduino commands 2022-06-05 21:20:43 +02:00
Joachim Stolberg
ac33080404 Fix command interface bugs 2022-05-22 15:20:42 +02:00
Joachim Stolberg
90dd1c3bbe Make collider expoint waiting time adjustable 2022-05-07 17:05:19 +02:00
Joachim Stolberg
54ed4e60c5 Fix wind turbine and concentrator bugs 2022-05-06 23:02:22 +02:00
Joachim Stolberg
4570a10241 Fix bugs for ta5 heat exchanger and ta4 electronic fab 2022-05-03 21:08:35 +02:00
Joachim Stolberg
192d46c682
Merge pull request #83 from Thomas--S/sequencer-on-off
TA4 Sequencer: Add 'on' and 'off' commands
2022-05-03 20:34:40 +02:00
Thomas--S
806af873b4 TA4 Sequencer: Add 'on' and 'off' commands
Allows the sequencer to be used with buttons, for example.
2022-05-02 17:12:52 +02:00
Joachim Stolberg
47c391c679 Fix bug with unconfigured turncontroller 2022-04-26 22:35:28 +02:00
Joachim Stolberg
3309316b18 Fix bug #81 2022-04-25 18:58:08 +02:00
Joachim Stolberg
094d448386 Fix bug #82 2022-04-25 18:00:26 +02:00
Joachim Stolberg
2df3d3a523 Fix bug #81 2022-04-24 20:39:26 +02:00
Joachim Stolberg
8b0d340344 Fix collider remove bug 2022-03-21 20:49:22 +01:00
Joachim Stolberg
e0269da493 Fix ta3 lightdetector drop bug 2022-03-11 21:46:36 +01:00
Joachim Stolberg
3488bdfed1 Fix bug after server crash 2022-02-25 23:00:17 +01:00
Joachim Stolberg
622a26d575
Merge pull request #77 from joe7575/wizardofgcc/master
Wizardofgcc/master
2022-02-23 19:07:00 +01:00
Joachim Stolberg
e3cdb47f9e Add German translation 2022-02-23 19:01:38 +01:00
Konstantin Logashenko
dfa9f2c7cb Update md manual file for light detector (lua file not generated) and add item entry to doc/items.lua 2022-02-22 11:50:35 +03:00
Konstantin Logashenko
598b0b9b11 Revert "Add Construction Board documentation for light detector"
This reverts commit 93deeb33d6.

Revert manual documentation, to add automatically generated one instead
2022-02-22 11:33:52 +03:00
Konstantin Logashenko
93deeb33d6 Add Construction Board documentation for light detector 2022-02-21 21:48:58 +03:00
Konstantin Logashenko
1306c9a0ba Revert "Add documentation for light detector (only English)"
This reverts commit 39cb0e150a.
2022-02-21 21:37:07 +03:00
Konstantin Logashenko
155d926479 Merge branch 'master' of https://github.com/wizardofgcc/techage 2022-02-21 21:31:30 +03:00
Konstantin Logashenko
39cb0e150a Add documentation for light detector (only English) 2022-02-21 21:29:43 +03:00
wizardofgcc
a5ca593b02
Merge branch 'joe7575:master' into master 2022-02-21 21:15:34 +03:00
Konstantin Logashenko
877d754c6a Textures for light detector 2022-02-07 16:53:56 +03:00
Konstantin Logashenko
3837e5a22b Make sure to update the init too 2022-02-07 16:50:44 +03:00
Konstantin Logashenko
94389990ed Implement the light detector (detects light level of the node above) 2022-02-07 16:50:06 +03:00
Joachim Stolberg
bdc6074790 Fix teleport pipe pump bug 2022-02-01 19:11:00 +01:00
Joachim Stolberg
7281ec7af7 Fix 'controller will not start' bug 2022-01-30 11:31:58 +01:00
Joachim Stolberg
c60b242c5d Fix FR controller command interface error 2022-01-24 17:54:50 +01:00
Joachim Stolberg
7ef1a81420 Merge branch 'fusion_reactor' 2022-01-23 17:19:15 +01:00
Joachim Stolberg
0f14d504d5 Fix fly controller 'move' bug 2022-01-07 17:29:56 +01:00
263 changed files with 23225 additions and 7790 deletions

43
.test/testblock.lua Normal file
View File

@ -0,0 +1,43 @@
local M = minetest.get_meta
minetest.register_node("techage:testblock", {
description = "Testblock",
tiles = {
"techage_top_ta4.png",
"techage_filling_ta4.png^techage_frame_ta4.png",
},
paramtype2 = "facedir",
groups = {cracky=2, crumbly=2, choppy=2},
is_ground_content = false,
after_place_node = function(pos, placer)
local nvm = techage.get_nvm(pos)
nvm.test_val = 1
M(pos):set_int("test_val", 1)
M(pos):set_string("infotext", "Value = " .. 1)
end,
})
minetest.register_lbm({
label = "Update testblock",
name = "techage:update_testblock",
nodenames = {
"techage:testblock",
},
run_at_every_load = true,
action = function(pos, node)
local nvm = techage.get_nvm(pos)
if M(pos):get_int("test_val") == nvm.test_val then
nvm.test_val = nvm.test_val + 1
M(pos):set_int("test_val", nvm.test_val)
M(pos):set_string("infotext", "Value = " .. nvm.test_val)
else
minetest.log("error", "[techage] Memory error at " .. minetest.pos_to_string(pos))
M(pos):set_string("infotext", "Error")
end
end,
})

View File

@ -629,8 +629,8 @@ to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
TechAge, a mod to go through 5 tech ages in search of wealth and power.
Copyright (C) 2019-2023 Joachim Stolberg
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by

159
README.md
View File

@ -2,12 +2,9 @@
Tech Age, a mod to go through 5 tech ages in search of wealth and power.
**Tech Age (techage) is the successor to TechPack V2, at first glance similar and yet completely different!**
![screenshot](https://github.com/joe7575/techage/blob/master/screenshot.png)
Important facts:
- techage is not backwards compatible and cannot be installed on a server together with TechPack
- techage is significantly more extensive, since additional mods are integrated
@ -22,22 +19,26 @@ Important facts:
In contrast to TechPack, the resources are more limited and it is much more difficult to pass all levels.
(no endless ore generation by means of cobble generators)
**Techage blocks store information outside of the block. This is for performance reasons.
If you move, place, or remove blocks with any tool, at best, only the information is lost.
In the worst case, the server crashes.**
[Manuals](https://github.com/joe7575/techage/wiki)
### License
Copyright (C) 2019-2022 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
Code: Licensed under the GNU AGPL version 3 or later. See LICENSE.txt
Textures: CC BY-SA 3.0
The TA1 mill sound is from https://freesound.org/people/JustinBW/sounds/70200/
The TA1 watermill sound is from https://freesound.org/people/bmoreno/sounds/164182/
Many thanks to Thomas-S and others for their contributions
Many thanks to Thomas-S, niklp09, and others for their contributions
### Dependencies
Required: default, doors, bucket, stairs, screwdriver, basic_materials, tubelib2, networks, minecart, lcdlib, safer_lua
Required: default, doors, bucket, stairs, screwdriver, basic_materials, tubelib2, networks, minecart, lcdlib, safer_lua, doclib
Recommended: signs_bot, hyperloop, compost, techpack_stairway, autobahn
Optional: unified_inventory, wielded_light, unifieddyes, lua-mashal, lsqlite3, moreores, ethereal, mesecon
@ -52,6 +53,7 @@ The following mods in the newest version have to be downloaded directly from Git
* [minecart](https://github.com/joe7575/minecart)
* [lcdlib](https://github.com/joe7575/lcdlib)
* [safer_lua](https://github.com/joe7575/safer_lua)
* [doclib](https://github.com/joe7575/doclib)
It is highly recommended that you install the following mods, too:
@ -60,26 +62,153 @@ It is highly recommended that you install the following mods, too:
* [compost](https://github.com/joe7575/compost): The garden soil is needed for the TA4 LED Grow Light based flower bed
* [techpack_stairway](https://github.com/joe7575/techpack_stairway): Ladders, stairways, and bridges for your machines
* [autobahn](https://github.com/joe7575/autobahn): Street blocks and slopes with stripes for faster traveling
* [[ta4_jetpack](https://github.com/joe7575/ta4_jetpack): A Jetpack with hydrogen as fuel and TA4 recipe
* [ta4_jetpack](https://github.com/joe7575/ta4_jetpack): A Jetpack with hydrogen as fuel and TA4 recipe
For large servers with many player `lsqlite3` is recommended.
The package has to be installed via [luarocks](https://luarocks.org/):
More recommended Techage related mods by other authors:
luarocks install lsqlite3
* [ta4_addons](https://github.com/Thomas--S/ta4_addons) from Thomas--S: A Touchscreen for the Lua controller
* [ts_vehicles](https://github.com/Thomas--S/ts_vehicles) from Thomas--S: A mod to provide cars and other vehicles for Minetest.
* [ta_apiary](https://gitlab.com/lesya_minetest_mods/ta_apiary) from Olesya Sibidanova: TechAge Machines for beekeeping
To enable this `unsafe` package, add 'techage' to the list of trusted mods in minetest.conf:
For large servers with many players, the following packages are recommended:
secure.trusted_mods = techage
* lua-mashal for faster serialization/deserialization of data
* lsqlite3 for storing node and network data
For the installation of 'luarocks' (if not already available), see [luarocks](https://luarocks.org/)
The packages have to be installed via [luarocks](https://luarocks.org/):
luarocks --lua-version 5.1 install lsqlite3
luarocks --lua-version 5.1 install lua-marshal
To enable these `unsafe` packages, add 'techage' and 'lua-marshal'
to the list of trusted mods in `minetest.conf`:
secure.trusted_mods = techage,lua-marshal
and add the following line to your `world.mt` or `minetest.conf`:
techage_use_sqlite = true
Available worlds will be converted to 'lsqlite3', but there is no way back, so:
** Never disable 'lsqlite3' for a world that has already been used!**
**Never disable 'lsqlite3' for a world that has already been used!**
### History
**2023-11-05 V1.18**
- Add TA2 clutch
- TA5 Generator: Add generator menu
- TA4 Injector: Allow rotation with a screwdriver
- Escape equal sign in german translation (Niklp09)
- Autocrafter: Add Beduino command interface
- Autocrafter: Add flush command
- Fix converter stores mesecon signals (Niklp09)
- TA1 Gravel Sieve: Use proper player creative check (Niklp09)
- TA4 Chest: Add storesize command
- Improve Assembly Tool
- Furnace: Fix burn time issue
- Allow further types of cobblestone for the coalburner
- Fix water mill river water bug (alwayshopeless)
- Improve manual
- Further improvements
**2023-08-25 V1.17**
- Add support for doclib / remove techage internal doc support
**The mod doclib is a new hard depenency !**
- Fix LICENCSE file bug
- Add beduino support for TA3 repeater (realmicu)
- Add inv_name_prefix to `techage.register_consumer` (debiankaios)
- Add generator menu to TA5 generator (fusion reactor)
- Adapt mod to the new lcdlib mod
- Fix some bugs
**2023-06-30 V1.16**
- Add TA4 node detector
- Add wrench menu to TA3 button
- Add arrows to the pump bottom and allow to turn the pump with the Techage Screwdriver
- Fix bug with configurred TA4 chest and TA5 teleport tubes
- Add gaze sensor
- Many bugfixes and improvements
**2023-05-05 V1.15**
- Allow energy storage with up to 13x13x13 concrete blocks
- Allow registration of other buckets
- Add hyperloop chest only if the hyperloop mod is available
- Add missing 'minetest.formspec_escape' #131
- Fix bug "Trouble with flycontroller #130"
- Add optional dependency on farming mod (orwell96)
- Fix forceload formspec receiver (Niklp09)
**2023-04-16 V1.14**
- Add file "api.md"
- Add API function `register_ore_for_gravelsieve`
- Add support for the game Asuna
- Merge pull request #124 from Niklp09/drops
- Fix keep node number issue
- Fix manual issue #123
**2023-04-10 V1.13**
- Add "Teleport mode" to the ta5 fly controller
**2023-04-01 V1.12**
- Improve Transformer:
- add wrench menu for 'max. power passed through'
- Increase max. power passed through from 100 to 300 ku
- Improve Electricmeter:
- add wrench menu for 'max. power passed through' and 'power countdown' 2458
- add commands to read the countdown value (Lua and Beduino controller)
- Improve TA3 Mesecons Converter:
- fix overload bug
- fix missing dominant 'on' issue
- Add version command to TA3/TA4 Terminal
- TA5 Hyperloop Chest: Disable inventory access on client side due to minetest core issues
**2023-03-05 V1.11**
- Reduce the number of necessary exp points for TA5 Hyperloop Chest,
TA5 Hyperloop Tank, and TA5 AI Chip II
- Fix possible kernel crashes with TA5 Hyperloop Chest and autocrafter
- Rework doorcontroller (menu changed)
- Increase tank cart storage size to 200 units
- Fix several paramtype/use_texture_alpha issues
- Add command 'load' to the TA4 power terminal
- Add beduino tank commands
- Fix power consumption bug for a stopped collider
- Fix electrolyzer formspec bug
- Add Rack and pinion node
- Expand ta4 sequencer wrench menu
- Accept mincart carts for the move controller
- movecontroller: Allow to move objects 'without' a move block
- Add empty_spool as fab output
- Fix doser goes blocked bug
**2023-02-04 V1.10**
- Improve flycontroller
- Remove handover for movecontroller
- Rename "techage:signal_lamp" to "techage:color_lamp"
- Rename "techage:signal_lamp2" to "techage:color_lamp2"
- Add countdown mode to TA4 Detector
- Adapt to new beduino and minecart versions
- Improve manuals
- flycontroller/movecontroller: Allow moving blocks through unloaded areas
- playerdetector: Add wrench menu to configure search radius
- Default furnace: Don't use items filled from the top as fuel
- Many further improvements and bug fixes from joe7575 and Niklp09
**2022-09-03 V1.09**
- Change the way items are pushed
- Add "Flow Limiter" mode to TA4 pump and TA4 pusher
**2022-06-06 V1.08**
- Native support for the mod Beduino added
**2022-01-22 V1.07**
- TA5 fusion reactor added

225
api.md Normal file
View File

@ -0,0 +1,225 @@
# Techage API Functions
Techage API function to adapt/prepare techage for other mods/games.
## Move/Fly Controller
Register node names for nodes allowed to be moved by fly/move controllers.
This is only necessary for undiggable/intelligent nodes with one of the following attributes:
- ```drop = ""```
- ```diggable = false```
- ```after_dig_node ~= nil```
```lua
techage.register_simple_nodes(node_names, is_valid)
```
- `is_valid = true` - Add node to the list of simple nodes
- `is_valid = false` - Remove node from the list of simple nodes
Example:
```lua
techage.register_simple_nodes({"techage:power_lineS"}, true)
```
For door nodes used as sliding doors by means of the move controller, call in addition:
```lua
techage.flylib.protect_door_from_being_opened(node_name)
```
## TA1 Hammer
Register stone/gravel name pair for the hammer blow:
```lua
techage.register_stone_gravel_pair(stone_name, gravel_name)
```
Example:
```lua
techage.register_stone_gravel_pair("default:stone", "default:gravel")
```
## TA1 Melting Pot
Register a pot recipe:
```lua
techage.ironage_register_recipe(recipe)
```
Examples:
```lua
techage.ironage_register_recipe({
output = "default:obsidian",
recipe = {"default:cobble"},
heat = 10, -- Corresponds to the tower height
time = 8, -- Cooking time in seconds
})
techage.ironage_register_recipe({
output = "default:bronze_ingot 4",
recipe = {"default:copper_ingot", "default:copper_ingot", "default:copper_ingot", "default:tin_ingot"},
heat = 4, -- Corresponds to the tower height
time = 8, -- Cooking time in seconds
})
```
## TA2/TA3/TA4 Autocrafter
Register any nodes/items that should not be crafted via the autocrafter.
```lua
techage.register_uncraftable_items(item_name)
```
## TA2/TA3/TA4 Gravel Sieve
Change the probability of ores or register new ores for sieving.
```lua
techage.register_ore_for_gravelsieve(ore_name, probability)
```
Example:
```lua
techage.register_ore_for_gravelsieve("default:iron_lump", 30)
```
Default values for MTG are:
```lua
-- higher value means less frequent occurrence
techage:baborium_lump 100000 -- hardly ever
default:mese_crystal 548 -- every 548th time
default:gold_lump 439
default:tin_lump 60
default:diamond 843
default:copper_lump 145
default:coal_lump 11
default:iron_lump 15
```
## TA2/TA3/TA4 Gravel Rinser
Add a rinser recipe.
```lua
techage.add_rinser_recipe(recipe)
```
Example:
```lua
techage.add_rinser_recipe({input = "techage:sieved_gravel", output = "techage:usmium_nuggets", probability = 30})
```
## TA2/TA3/TA4 Grinder
Add a grinder recipe.
```lua
techage.add_grinder_recipe(recipe, ta1_permitted)
```
Examples:
```lua
echage.add_grinder_recipe({input = "default:cobble", output = "default:gravel"})
techage.add_grinder_recipe({input = "default:sandstone", output = "default:sand 4"})
```
## TA3/TA4 Electronic Fab, TA4 Doser
Add recipes to an electronic fab or doser (chemical reactor):
```lua
techage.recipes.add(rtype, recipe)
```
`rtype` is one of: `ta2_electronic_fab` , `ta4_doser`
A recipe look like:
```
{
output = "<item-name> <units>", -- units = 1..n
waste = "<item-name> <units>", -- units = 1..n
input = { -- up to 4 items
"<item-name> <units>",
"<item-name> <units>",
},
}
```
Examples:
```lua
techage.recipes.add("ta2_electronic_fab", {
output = "techage:vacuum_tube 2",
waste = "basic_materials:empty_spool 1",
input = {"default:glass 1", "basic_materials:copper_wire 1", "basic_materials:plastic_sheet 1", "techage:usmium_nuggets 1"}
})
techage.recipes.add("ta4_doser", {
output = "techage:naphtha 1",
input = {
"techage:fueloil 1",
},
catalyst = "techage:gibbsite_powder",
})
```
## TA3 Furnace
Register recipe:
```lua
techage.furnace.register_recipe(recipe)
```
Example:
```lua
techage.furnace.register_recipe({
output = "default:bronze_ingot 4",
recipe = {"default:copper_ingot", "default:copper_ingot", "default:copper_ingot", "default:tin_ingot"},
time = 2, -- in seconds
})
```
## Assembly Tool
Disable a block from being removed by the assembly tool:
```lua
techage.disable_block_for_assembly_tool(block_name)
```

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -68,6 +68,21 @@ local function count_index(invlist)
return index
end
local function flush_input_inventory(pos)
local inv = M(pos):get_inventory()
if not inv:is_empty("src") then
for idx = 1, 16 do
local stack = inv:get_stack("src", idx)
if not inv:room_for_item("dst", stack) then
return false
end
inv:add_item("dst", stack)
inv:set_stack("src", idx, nil)
end
end
return true
end
-- caches some recipe data
local autocrafterCache = {}
@ -224,13 +239,18 @@ local function on_output_change(pos, inventory, stack)
end
local function determine_recipe_items(pos, input)
if input and type(input) == "string" then
-- Test if "<node-number>.<recipe-number>" input
local num, idx = unpack(string.split(input, ".", false, 1))
if num and idx then
input = get_input_from_recipeblock(pos, num, idx)
end
local num, idx
if input and type(input) == "string" then -- Lua controller
-- Test if "<node-number>.<recipe-number>" input
num, idx = unpack(string.split(input, ".", false, 1))
elseif input and type(input) == "table" then -- Beduino
num = tostring(input[1] * 65536 + input[2])
idx = tostring(input[3])
end
if num and idx then
input = get_input_from_recipeblock(pos, num, idx)
if input then
-- "<item>,<item>,..." input
local items = string.split(input, ",", true, 8)
@ -243,29 +263,28 @@ end
local function on_new_recipe(pos, input)
local items = determine_recipe_items(pos, input)
local inv = M(pos):get_inventory()
if items then
input = {
method = "normal",
width = 3,
items = items,
}
local output, _ = minetest.get_craft_result(input)
if output.item:get_name() ~= "" then
local inv = M(pos):get_inventory()
for i = 1, 9 do
inv:set_stack("recipe", i, input.items[i])
end
after_recipe_change(pos, inv)
for i = 1, 9 do
inv:set_stack("recipe", i, items[i])
end
else
local inv = M(pos):get_inventory()
inv:set_list("recipe", {})
after_recipe_change(pos, inv)
end
local hash = minetest.hash_node_position(pos)
autocrafterCache[hash] = nil
local craft = get_craft(pos, inv, hash)
if craft.output and craft.output.item then
inv:set_stack("output", 1, craft.output.item)
else
inv:set_stack("output", 1, nil)
end
end
local function allow_metadata_inventory_put(pos, listname, index, stack, player)
if listname == "output" then
return 0
end
if minetest.is_protected(pos, player:get_player_name()) then
return 0
end
@ -285,6 +304,9 @@ local function allow_metadata_inventory_put(pos, listname, index, stack, player)
end
local function allow_metadata_inventory_take(pos, listname, index, stack, player)
if listname == "output" then
return 0
end
if minetest.is_protected(pos, player:get_player_name()) then
return 0
end
@ -302,6 +324,9 @@ local function allow_metadata_inventory_take(pos, listname, index, stack, player
end
local function allow_metadata_inventory_move(pos, from_list, from_index, to_list, to_index, count, player)
if from_list == "output" or "to_list" == "output" then
return 0
end
if minetest.is_protected(pos, player:get_player_name()) then
return 0
end
@ -364,7 +389,7 @@ tiles.pas = {
tiles.act = {
-- up, down, right, left, back, front
{
image = "techage_filling4_ta#.png^techage_appl_autocrafter4.png^techage_frame4_ta#_top.png",
name = "techage_filling4_ta#.png^techage_appl_autocrafter4.png^techage_frame4_ta#_top.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -377,7 +402,7 @@ tiles.act = {
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_outp.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_inp.png",
{
image = "techage_filling4_ta#.png^techage_appl_autocrafter4.png^techage_frame4_ta#.png",
name = "techage_filling4_ta#.png^techage_appl_autocrafter4.png^techage_frame4_ta#.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -387,7 +412,7 @@ tiles.act = {
},
},
{
image = "techage_filling4_ta#.png^techage_appl_autocrafter4.png^techage_frame4_ta#.png",
name = "techage_filling4_ta#.png^techage_appl_autocrafter4.png^techage_frame4_ta#.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -434,19 +459,36 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
if topic == "recipe" and CRD(pos).stage == 4 then
if payload and payload ~= "" then
local inv = M(pos):get_inventory()
on_new_recipe(pos, payload)
return true
else
local inv = M(pos):get_inventory()
return inv:get_stack("output", 1):get_name()
end
elseif topic == "flush" and CRD(pos).stage == 4 then
return flush_input_inventory(pos)
elseif topic == "info" and CRD(pos).stage == 4 then
return INFO
else
return CRD(pos).State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
if topic == 10 and CRD(pos).stage == 4 then
on_new_recipe(pos, payload)
return 1, ""
elseif topic == 11 and CRD(pos).stage == 4 then
if flush_input_inventory(pos) then
return 1, ""
else
return 0, ""
end
end
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
end,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -180,6 +180,15 @@ techage.register_node({"techage:chest_ta2", "techage:chest_ta3"}, {
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 131 then
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return 0, {techage.get_inv_state_num(inv, "main")}
else
return 2, ""
end
end,
})
@ -412,6 +421,15 @@ techage.register_node({"techage:chest_ta4"}, {
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 131 then
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return 0, {techage.get_inv_state_num(inv, "main")}
else
return 2, ""
end
end,
})
minetest.register_craft({

View File

@ -65,10 +65,18 @@ local names = networks.register_junction("techage:concentrator", 2/8, Boxes, Tub
end,
}, 27)
for _, name in ipairs(names) do
Tube:set_valid_sides(name, {"B", "R", "F", "L", "D", "U"})
end
techage.register_node(names, {
on_push_item = function(pos, in_dir, stack)
local push_dir = M(pos):get_int("push_dir")
return techage.safe_push_items(pos, push_dir, stack)
if networks.Flip[push_dir] ~= in_dir then
return techage.safe_push_items(pos, push_dir, stack)
else
return stack
end
end,
is_pusher = true, -- is a pulling/pushing node
})
@ -110,10 +118,18 @@ names = networks.register_junction("techage:ta4_concentrator", 2/8, Boxes, Tube,
end,
}, 27)
for _, name in ipairs(names) do
Tube:set_valid_sides(name, {"B", "R", "F", "L", "D", "U"})
end
techage.register_node(names, {
on_push_item = function(pos, in_dir, stack)
local push_dir = M(pos):get_int("push_dir")
return techage.safe_push_items(pos, push_dir, stack)
if networks.Flip[push_dir] ~= in_dir then
return techage.safe_push_items(pos, push_dir, stack)
else
return stack
end
end,
is_pusher = true, -- is a pulling/pushing node
})

View File

@ -104,7 +104,7 @@ local function prepare_tiles(tiles, stage, power_png)
tbl[#tbl+1] = item:gsub("#", stage):gsub("{power}", power_png):gsub("@@", '#')
else
local temp = table.copy(item)
temp.image = temp.image:gsub("#", stage):gsub("{power}", power_png):gsub("@@", '#')
temp.name = temp.name:gsub("#", stage):gsub("{power}", power_png):gsub("@@", '#')
tbl[#tbl+1] = temp
end
end
@ -113,16 +113,21 @@ end
-- 'validStates' is optional and can be used to e.g. enable
-- only one TA2 node {false, true, false, false}
function techage.register_consumer(base_name, inv_name, tiles, tNode, validStates, node_name_prefix)
function techage.register_consumer(base_name, inv_name, tiles, tNode, validStates, node_name_prefix, inv_name_prefix)
local names = {}
validStates = validStates or {true, true, true, true}
if not node_name_prefix then
node_name_prefix = "techage:ta"
node_name_prefix = node_name_prefix or "techage:ta"
if inv_name_prefix then
inv_name_prefix = inv_name_prefix.." "
else
inv_name_prefix = ""
end
for stage = 2,5 do
local name_pas = node_name_prefix..stage.."_"..base_name.."_pas"
local name_act = node_name_prefix..stage.."_"..base_name.."_act"
local name_inv = "TA"..stage.." "..inv_name
local name_inv = inv_name_prefix.."TA"..stage.." "..inv_name
names[#names+1] = name_pas
if validStates[stage] then
@ -230,6 +235,8 @@ function techage.register_consumer(base_name, inv_name, tiles, tNode, validState
on_metadata_inventory_put = tNode.on_metadata_inventory_put,
on_metadata_inventory_take = tNode.on_metadata_inventory_take,
ta_rotate_node = tNode.ta_rotate_node,
ta3_formspec = stage == 3 and tNode.ta3_formspec,
ta4_formspec = stage == 4 and tNode.ta4_formspec,
paramtype = tNode.paramtype,
paramtype2 = "facedir",
@ -271,6 +278,8 @@ function techage.register_consumer(base_name, inv_name, tiles, tNode, validState
on_metadata_inventory_put = tNode.on_metadata_inventory_put,
on_metadata_inventory_take = tNode.on_metadata_inventory_take,
ta_rotate_node = tNode.ta_rotate_node,
ta3_formspec = stage == 3 and tNode.ta3_formspec,
ta4_formspec = stage == 4 and tNode.ta4_formspec,
paramtype = tNode.paramtype,
paramtype2 = "facedir",

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -34,6 +34,7 @@ local INFO = [[Turn port on/off or read its state: command = 'port', payload = r
--local Side2Color = {B="red", L="green", F="blue", R="yellow"}
local SlotColors = {"red", "green", "blue", "yellow"}
local SlotNumbers = {red = 1, green = 2, blue = 3, yellow = 4}
local Num2Ascii = {"B", "L", "F", "R"}
local FilterCache = {} -- local cache for filter settings
@ -276,10 +277,17 @@ local function push_item(pos, base_filter, itemstack, num_items, nvm)
num_of_trials = num_of_trials + 1
local push_dir = filter[idx]
local num_to_push = math.min(amount, num_items - num_pushed)
if techage.push_items(pos, push_dir, itemstack:peek_item(num_to_push)) then
num_pushed = num_pushed + num_to_push
nvm.port_counter[push_dir] = (nvm.port_counter[push_dir] or 0) + num_to_push
local leftover = techage.push_items(pos, push_dir, itemstack:peek_item(num_to_push))
local pushed
if not leftover then
pushed = 0
elseif leftover ~= true then
pushed = num_to_push - leftover:get_count()
else -- leftover == true
pushed = num_to_push
end
num_pushed = num_pushed + pushed
nvm.port_counter[push_dir] = (nvm.port_counter[push_dir] or 0) + pushed
-- filter start offset
idx = idx + 1
if idx > num_ports then
@ -383,16 +391,16 @@ end
-- techage command to turn on/off filter channels
local function change_filter_settings(pos, slot, val)
local slots = {["red"] = 1, ["green"] = 2, ["blue"] = 3, ["yellow"] = 4}
local meta = M(pos)
local filter = minetest.deserialize(meta:get_string("filter")) or {false,false,false,false}
local num = slots[slot] or 1
local num = SlotNumbers[slot] or 1
if num >= 1 and num <= 4 then
filter[num] = val == "on"
end
meta:set_string("filter", minetest.serialize(filter))
filter_settings(pos)
local hash = minetest.hash_node_position(pos)
FilterCache[hash] = nil
local nvm = techage.get_nvm(pos)
meta:set_string("formspec", formspec(CRD(pos).State, pos, nvm))
@ -401,9 +409,45 @@ end
-- techage command to read filter channel status (on/off)
local function read_filter_settings(pos, slot)
local slots = {["red"] = 1, ["green"] = 2, ["blue"] = 3, ["yellow"] = 4}
local filter = minetest.deserialize(M(pos):get_string("filter")) or {false,false,false,false}
return filter[slots[slot]] and "on" or "off"
return filter[SlotNumbers[slot]] and "on" or "off"
end
local function get_payload_values(payload)
local color
local idx = 0
local items = {ItemStack(""), ItemStack(""), ItemStack(""), ItemStack(""), ItemStack(""), ItemStack("")}
for s in payload:gmatch("[^%s]+") do --- white spaces
if not color then
if SlotNumbers[s] then
color = s
else
return "red", {}
end
else
idx = idx + 1
if idx <= 6 then
items[idx] = ItemStack(s)
end
end
end
return color, items
end
local function str_of_inv_items(pos, color)
color = SlotColors[color] or color
if SlotNumbers[color] then
local inv = M(pos):get_inventory()
local t = {}
for idx = 1, 6 do
local item = inv:get_stack(color, idx)
if item:get_count() > 0 then
t[#t + 1] = item:get_name()
end
end
return table.concat(t, " ")
end
return ""
end
local function can_dig(pos, player)
@ -431,7 +475,7 @@ local get_tiles = function(is_hp)
tiles.act = {
-- up, down, right, left, back, front
{
image = "techage_filling4_ta#.png^techage_appl_distri4.png^techage_frame4_ta#_top"..variant..".png^techage_appl_color_top4.png",
name = "techage_filling4_ta#.png^techage_appl_distri4.png^techage_frame4_ta#_top"..variant..".png^techage_appl_color_top4.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -474,10 +518,47 @@ local tubing = {
else
return change_filter_settings(pos, slot, val)
end
elseif topic == "config" then
local color, items = get_payload_values(payload)
local inv = M(pos):get_inventory()
for idx,item in ipairs(items) do
inv:set_stack(color, idx, item)
end
local hash = minetest.hash_node_position(pos)
FilterCache[hash] = nil
return true
elseif topic == "get" then
return str_of_inv_items(pos, payload)
else
return CRD(pos).State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
if topic == 4 then
local slot = SlotColors[payload[1]]
local state = payload[2] == 1 and "on" or "off"
change_filter_settings(pos, slot, state)
return 0
elseif topic == 67 then
local color, items = get_payload_values(payload)
local inv = M(pos):get_inventory()
for idx,item in ipairs(items) do
inv:set_stack(color, idx, item)
end
local hash = minetest.hash_node_position(pos)
FilterCache[hash] = nil
return 0
else
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 148 then
return 0, str_of_inv_items(pos, payload[1])
else
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
end,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -26,7 +26,7 @@ local recipes = techage.recipes
local RecipeType = {
[2] = "ta2_electronic_fab",
[3] = "ta3_electronic_fab",
[3] = "ta3_electronic_fab",
[4] = "ta4_electronic_fab",
}
@ -73,11 +73,26 @@ local function allow_metadata_inventory_take(pos, listname, index, stack, player
return stack:get_count()
end
local function get_original_waste(inv, waste)
-- Waste has meta data, so we need to find the original waste item
for i = 1, 8 do
local stack = inv:get_stack("src", i)
if stack:get_count() == 1 then
if stack:get_name() == waste:get_name() then
return stack
end
end
end
return waste
end
local function making(pos, crd, nvm, inv)
local owner = M(pos):get_string("owner")
local rtype = RecipeType[crd.stage]
local recipe = recipes.get(nvm, rtype)
local output = ItemStack(recipe.output.name.." "..recipe.output.num)
if inv:room_for_item("dst", output) then
local recipe = recipes.get(nvm, rtype, owner)
local output = ItemStack(recipe.output.name .. " " .. recipe.output.num)
local waste = recipe.waste and ItemStack(recipe.waste.name .. " " .. recipe.waste.num)
if inv:room_for_item("dst", output) and (not waste or inv:room_for_item("dst", waste)) then
for _,item in ipairs(recipe.input) do
local input = ItemStack(item.name.." "..item.num)
if not inv:contains_item("src", input) then
@ -85,11 +100,25 @@ local function making(pos, crd, nvm, inv)
return
end
end
-- For some recipes, an item customized via metadata is used as a copy template.
-- This allows specially programmed items such as ROM chips to be produced.
-- The metadata of the copy template must be passed to the on_production function.
-- At the same time, the metadata of the copy template must not be lost when moving
-- as 'waste' to the output inventory.
local idef = minetest.registered_items[recipe.output.name]
if waste and idef and idef.on_production then
waste = get_original_waste(inv, waste)
local metadata = waste:get_meta():to_table().fields or {}
output = idef.on_production(output, metadata)
end
for _,item in ipairs(recipe.input) do
local input = ItemStack(item.name.." "..item.num)
inv:remove_item("src", input)
end
inv:add_item("dst", output)
if waste then
inv:add_item("dst", waste)
end
crd.State:keep_running(pos, nvm, COUNTDOWN_TICKS)
return
end
@ -147,7 +176,7 @@ tiles.act = {
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_outp.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_inp.png",
{
image = "techage_filling4_ta#.png^techage_appl_electronic_fab4.png^techage_frame4_ta#.png",
name = "techage_filling4_ta#.png^techage_appl_electronic_fab4.png^techage_frame4_ta#.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -157,7 +186,7 @@ tiles.act = {
},
},
{
image = "techage_filling4_ta#.png^techage_appl_electronic_fab4.png^techage_frame4_ta#.png",
name = "techage_filling4_ta#.png^techage_appl_electronic_fab4.png^techage_frame4_ta#.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -202,6 +231,12 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
return CRD(pos).State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
end,

View File

@ -78,7 +78,11 @@ local function del_pos(pos, player)
local meta = player:get_meta()
local lPos = minetest.deserialize(meta:get_string("techage_forceload_blocks")) or {}
lPos = remove_list_elem(lPos, pos)
meta:set_string("techage_forceload_blocks", minetest.serialize(lPos))
if next(lPos) then
meta:set_string("techage_forceload_blocks", minetest.serialize(lPos))
else
meta:set_string("techage_forceload_blocks", "")
end
end
local function get_pos_list(player)
@ -88,16 +92,20 @@ end
local function set_pos_list(player, lPos)
local meta = player:get_meta()
meta:set_string("techage_forceload_blocks", minetest.serialize(lPos))
if next(lPos) then
meta:set_string("techage_forceload_blocks", minetest.serialize(lPos))
else
meta:set_string("techage_forceload_blocks", "")
end
end
local function shoe_flbs(pos, name, range)
local function show_flbs(pos, name, range)
local pos1 = {x=pos.x-range, y=pos.y-range, z=pos.z-range}
local pos2 = {x=pos.x+range, y=pos.y+range, z=pos.z+range}
for _,npos in ipairs(minetest.find_nodes_in_area(pos1, pos2, {"techage:forceload", "techage:forceloadtile"})) do
local _pos1, _pos2 = calc_area(npos)
local owner = M(npos):get_string("owner")
techage.mark_region(name, _pos1, _pos2, owner)
techage.mark_region(name, _pos1, _pos2, owner .. " " .. P2S(npos))
end
end
@ -114,20 +122,26 @@ local function formspec(name)
if player then
local lPos = get_pos_list(player)
local tRes = {}
for idx,pos in ipairs(lPos) do
tRes[#tRes+1] = "#"
tRes[#tRes+1] = S("Block at pos")
tRes[#tRes+1] = S("Area from")
tRes[#tRes+1] = S("Area to")
tRes[#tRes+1] = S("Status")
for idx,pos in ipairs(lPos) do
local pos1, pos2 = calc_area(pos)
tRes[#tRes+1] = idx
tRes[#tRes+1] = minetest.formspec_escape(P2S(pos))
tRes[#tRes+1] = minetest.formspec_escape(P2S(pos1))
tRes[#tRes+1] = "to"
tRes[#tRes+1] = minetest.formspec_escape(P2S(pos2))
tRes[#tRes+1] = minetest.forceload_block(pos, true) and 'Loaded' or 'Unloaded'
end
return "size[7,9]"..
return "size[9,9]"..
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
"label[0,0;"..S("List of your Forceload Blocks:").."]"..
"tablecolumns[text,width=1.2;text,width=12;text,width=1.6;text,width=12]"..
"table[0,0.6;6.8,8.4;output;"..table.concat(tRes, ",")..";1]"
"tablecolumns[text,width=1.8;text,width=12;text,width=12;text,width=12;text,width=12]"..
"table[0,0.6;8.8,8.4;output;"..table.concat(tRes, ",")..";1]"
end
end
@ -169,7 +183,7 @@ local function on_rightclick(pos, node, clicker, itemstack, pointed_thing)
if name == owner or minetest.check_player_privs(name, "server") then
local s = formspec(owner)
if s then
minetest.show_formspec(owner, "techage:forceload", s)
minetest.show_formspec(name, "techage:forceload", s)
end
end
end
@ -186,7 +200,7 @@ minetest.register_node("techage:forceload", {
'techage_filling_ta2.png^techage_frame_ta2_top.png',
'techage_filling_ta2.png^techage_frame_ta2_top.png',
{
image = "techage_filling_ta2.png^techage_frame_ta2_top.png^techage_appl_forceload.png",
name = "techage_filling_ta2.png^techage_frame_ta2_top.png^techage_appl_forceload.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -204,6 +218,7 @@ minetest.register_node("techage:forceload", {
paramtype = "light",
sunlight_propagates = true,
use_texture_alpha = techage.CLIP,
groups = {choppy=2, cracky=2, crumbly=2,
digtron_protected = 1,
not_in_creative_inventory = techage.max_num_forceload_blocks == 0 and 1 or 0},
@ -216,7 +231,7 @@ minetest.register_node("techage:forceloadtile", {
tiles = {
-- up, down, right, left, back, front
{
image = "techage_filling_ta2.png^techage_frame_ta2_top.png^techage_appl_forceload.png",
name = "techage_filling_ta2.png^techage_frame_ta2_top.png^techage_appl_forceload.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -265,6 +280,11 @@ if techage.max_num_forceload_blocks > 0 then
output = "techage:forceloadtile",
recipe = {"techage:forceload"},
})
minetest.register_craft({
type = "shapeless",
output = "techage:forceload",
recipe = {"techage:forceloadtile"},
})
end
minetest.register_on_joinplayer(function(player)
@ -292,15 +312,29 @@ minetest.register_chatcommand("forceload", {
params = "",
description = S("Show all forceload blocks in a 64x64x64 range"),
func = function(name, param)
if minetest.check_player_privs(name, "superminer") then
local player = minetest.get_player_by_name(name)
if player then
local pos = player:get_pos()
pos = vector.round(pos)
shoe_flbs(pos, name, 64)
end
else
return false, S("Priv missing")
local player = minetest.get_player_by_name(name)
if player then
local pos = player:get_pos()
pos = vector.round(pos)
show_flbs(pos, name, 64)
end
end,
})
minetest.register_chatcommand("forceload_verify", {
params = "",
description = "Checks each forceload block and returns a count of active/placed blocks",
func = function(name, param)
local player = minetest.get_player_by_name(name)
if player then
local loaded = {}
local wanted = get_pos_list(player)
for _,pos in ipairs(wanted) do
if minetest.forceload_block(pos, true) then
loaded[#loaded+1] = pos
end
end
minetest.chat_send_player(name, "Found "..#loaded.." out of ".. #wanted .. " force loads")
end
end,
})

View File

@ -81,7 +81,11 @@ techage.register_node({"shop:shop"}, {
on_inv_request = function(pos, in_dir, access_type)
local meta = minetest.get_meta(pos)
if is_owner(pos, meta) then
return meta:get_inventory(), "main"
if access_type == "push" then
return meta:get_inventory(), "stock"
elseif access_type == "pull" then
return meta:get_inventory(), "register"
end
end
end,
on_pull_item = function(pos, in_dir, num)
@ -109,17 +113,19 @@ techage.register_node({"default:furnace", "default:furnace_active"}, {
local inv = meta:get_inventory()
return techage.get_items(pos, inv, "dst", num)
end,
on_push_item = function(pos, side, stack)
on_push_item = function(pos, in_dir, stack)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
minetest.get_node_timer(pos):start(1.0)
if minetest.get_craft_result({method="fuel", width=1, items={stack}}).time ~= 0 then
if in_dir == 5 then
return techage.put_items(inv, "src", stack)
elseif minetest.get_craft_result({method="fuel", width=1, items={stack}}).time ~= 0 then
return techage.put_items(inv, "fuel", stack)
else
return techage.put_items(inv, "src", stack)
end
end,
on_unpull_item = function(pos, side, stack)
on_unpull_item = function(pos, in_dir, stack)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.put_items(inv, "dst", stack)

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -207,7 +207,7 @@ tiles.pas = {
tiles.act = {
-- up, down, right, left, back, front
{
image = "techage_appl_rinser4_top.png^techage_frame4_ta#_top.png",
name = "techage_appl_rinser4_top.png^techage_frame4_ta#_top.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -249,6 +249,12 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
return CRD(pos).State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
on_node_load = function(pos)
remove_objects({x=pos.x, y=pos.y+1, z=pos.z})
CRD(pos).State:on_node_load(pos)

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -133,7 +133,7 @@ tiles.pas = {
tiles.act = {
-- up, down, right, left, back, front
{
image = "techage_appl_sieve4_top.png^techage_frame4_ta#_top.png",
name = "techage_appl_sieve4_top.png^techage_frame4_ta#_top.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -174,6 +174,12 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
return CRD(pos).State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
end,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -17,7 +17,7 @@ local M = minetest.get_meta
local S = techage.S
-- Consumer Related Data
local CRD = function(pos) return (minetest.registered_nodes[techage.get_node_lvm(pos).name] or {}).consumer end
local CRD = function(pos) return (minetest.registered_nodes[techage.get_node_lvm(pos).name] or {}).consumer or {} end
local STANDBY_TICKS = 3
local COUNTDOWN_TICKS = 4
@ -56,7 +56,10 @@ local function allow_metadata_inventory_put(pos, listname, index, stack, player)
return 0
end
if listname == "src" then
CRD(pos).State:start_if_standby(pos)
local state = CRD(pos).State
if state then
state:start_if_standby(pos)
end
end
return stack:get_count()
end
@ -164,7 +167,7 @@ tiles.pas = {
tiles.act = {
-- up, down, right, left, back, front
{
image = "techage_appl_grinder4.png^techage_frame4_ta#_top.png",
name = "techage_appl_grinder4.png^techage_frame4_ta#_top.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -206,6 +209,12 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
return CRD(pos).State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
end,
@ -422,4 +431,5 @@ if minetest.global_exists("farming") then
techage.add_grinder_recipe({input="farming:seed_rice 6", output="farming:rice_flour"}, true)
techage.add_grinder_recipe({input="farming:oat 3", output="farming:flour"}, true)
techage.add_grinder_recipe({input="farming:seed_oat 6", output="farming:flour"}, true)
techage.add_grinder_recipe({input="farming:seed_cotton 3", output="basic_materials:oil_extract"}, true)
end

View File

@ -73,11 +73,17 @@ minetest.register_node("techage:itemsource", {
local stack = inv:get_stack('main', 1)
if stack:get_count() > 0 then
local push_dir = meta:get_int("push_dir")
if techage.push_items(pos, push_dir, stack) then
local cnt = meta:get_int("counter") + stack:get_count()
meta:set_int("counter", cnt)
meta:set_string("infotext", "Techage Item Source: "..cnt)
local leftover = techage.push_items(pos, push_dir, stack)
local pushed
if not leftover then
pushed = 0
elseif leftover ~= true then
pushed = stack:get_count() - leftover:get_count()
else -- leftover == true
pushed = stack:get_count()
end
meta:set_int("counter", pushed)
meta:set_string("infotext", "Techage Item Source: "..pushed)
end
return true
end,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -136,7 +136,7 @@ tiles.act = {
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_outp.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_inp.png",
{
image = "techage_filling4_ta#.png^techage_liquidsampler4.png^techage_frame4_ta#.png",
name = "techage_filling4_ta#.png^techage_liquidsampler4.png^techage_frame4_ta#.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -173,6 +173,12 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
return CRD(pos).State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
}
local node_name_ta2, node_name_ta3, _ =

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -34,6 +34,16 @@ local STANDBY_TICKS = 2
local COUNTDOWN_TICKS = 4
local CYCLE_TIME = 2
local WRENCH_MENU = {
{
type = "number",
name = "limit",
label = S("Number of items"),
tooltip = S("Number of items that are allowed to be pushed"),
default = "0",
},
}
local function ta4_formspec(self, pos, nvm)
if CRD(pos).stage == 4 then -- TA4 node?
return "size[8,7.2]"..
@ -42,7 +52,8 @@ local function ta4_formspec(self, pos, nvm)
default.gui_slots..
"box[0,-0.1;7.8,0.5;#c6e8ff]"..
"label[3,-0.1;"..minetest.colorize("#000000", S("Pusher")).."]"..
techage.question_mark_help(8, S("Optionally configure\nthe pusher with one item"))..
techage.question_mark_help(7.5, S("Optionally configure\nthe pusher with one item"))..
techage.wrench_image(7.4, -0.05) ..
"list[context;main;3.5,0.8;1,1;]"..
"image_button[3.5,2;1,1;".. self:get_state_button_image(nvm) ..";state_button;]"..
"tooltip[3.5,2;1,1;"..self:get_state_tooltip(nvm).."]"..
@ -87,30 +98,72 @@ local function allow_metadata_inventory_take(pos, listname, index, stack, player
return 0
end
local function pushing(pos, crd, meta, nvm)
local pull_dir = meta:get_int("pull_dir")
local push_dir = meta:get_int("push_dir")
local num = nvm.item_count or nvm.num_items or crd.num_items
local function set_limit(pos, nvm, val)
val = tonumber(val) or 0
if val > 0 then
nvm.limit = val
nvm.num_items = 0
M(pos):set_int("limit", val)
else
nvm.limit = nil
nvm.num_items = nil
M(pos):set_string("limit", "")
end
end
-- Function returns the number of pushed items
local function push(pos, crd, meta, nvm, pull_dir, push_dir, num)
local items = techage.pull_items(pos, pull_dir, num, nvm.item_name)
if items ~= nil then
if techage.push_items(pos, push_dir, items) ~= true then
local taken = items:get_count()
local leftover = techage.push_items(pos, push_dir, items)
if not leftover then
-- place item back
techage.unpull_items(pos, pull_dir, items)
crd.State:blocked(pos, nvm)
return
return 0
elseif leftover ~= true then
-- place item back
taken = taken - leftover:get_count()
techage.unpull_items(pos, pull_dir, leftover)
crd.State:blocked(pos, nvm)
return taken
end
if nvm.item_count then -- remote job?
nvm.item_count = nil
nvm.item_name = nil
crd.State:stop(pos, nvm)
local number = M(pos):get_string("node_number")
techage.send_single(number, nvm.rmt_num, "off")
else
crd.State:keep_running(pos, nvm, COUNTDOWN_TICKS)
end
return
return taken
end
crd.State:idle(pos, nvm)
return 0
end
local function pushing(pos, crd, meta, nvm)
local pull_dir = meta:get_int("pull_dir")
local push_dir = meta:get_int("push_dir")
if not nvm.limit then
local num = nvm.item_count or nvm.num_items or crd.num_items
num = push(pos, crd, meta, nvm, pull_dir, push_dir, num)
if num > 0 then
if nvm.item_count then
nvm.item_count = nvm.item_count - num
if nvm.item_count <= 0 then
crd.State:stop(pos, nvm)
nvm.item_count = nil
end
end
crd.State:keep_running(pos, nvm, COUNTDOWN_TICKS)
end
elseif nvm.num_items < nvm.limit then
local num = math.min(crd.num_items, nvm.limit - nvm.num_items)
num = push(pos, crd, meta, nvm, pull_dir, push_dir, num)
if num > 0 then
nvm.num_items = nvm.num_items + num
if nvm.num_items >= nvm.limit then
crd.State:stop(pos, nvm)
else
crd.State:keep_running(pos, nvm, COUNTDOWN_TICKS)
end
end
end
end
local function keep_running(pos, elapsed)
@ -180,14 +233,34 @@ local function can_start(pos, nvm, state)
return true
end
local function ta_after_formspec(pos, fields, playername)
local nvm = techage.get_nvm(pos)
set_limit(pos, nvm, fields.limit)
end
local function on_state_change(pos, old_state, new_state)
if old_state == techage.STOPPED and new_state == techage.RUNNING then
local nvm = techage.get_nvm(pos)
set_limit(pos, nvm, M(pos):get_int("limit"))
end
end
local function config_item(pos, payload)
local name, count = unpack(payload:split(" "))
if name and (minetest.registered_nodes[name] or minetest.registered_items[name]
or minetest.registered_craftitems[name]) then
count = tonumber(count) or 1
local inv = M(pos):get_inventory()
inv:set_stack("main", 1, {name = name, count = 1})
return count
if type(payload) == "string" then
if payload == "" then
local inv = M(pos):get_inventory()
inv:set_stack("main", 1, nil)
return 0
else
local name, count = unpack(payload:split(" "))
if name and (minetest.registered_nodes[name] or minetest.registered_items[name]
or minetest.registered_craftitems[name]) then
count = tonumber(count) or 1
local inv = M(pos):get_inventory()
inv:set_stack("main", 1, {name = name, count = 1})
return count
end
end
end
return 0
end
@ -210,7 +283,7 @@ tiles.act = {
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_outp.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_inp.png",
{
image = "techage_appl_pusher14.png^[transformR180]^techage_frame14_ta#.png",
name = "techage_appl_pusher14.png^[transformR180]^techage_frame14_ta#.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -220,7 +293,7 @@ tiles.act = {
},
},
{
image = "techage_appl_pusher14.png^techage_frame14_ta#.png",
name = "techage_appl_pusher14.png^techage_frame14_ta#.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -239,23 +312,57 @@ local tubing = {
is_pusher = true, -- is a pulling/pushing node
on_recv_message = function(pos, src, topic, payload)
if topic == "pull" then
if topic == "pull" then -- Deprecated command, use config/limit/start instead
local nvm = techage.get_nvm(pos)
CRD(pos).State:stop(pos, nvm)
nvm.item_count = math.min(config_item(pos, payload), 12)
nvm.rmt_num = src
CRD(pos).State:start(pos, nvm)
return true
elseif topic == "config" then
elseif topic == "config" then -- Set item type
local nvm = techage.get_nvm(pos)
CRD(pos).State:stop(pos, nvm)
config_item(pos, payload)
CRD(pos).State:start(pos, nvm)
return true
elseif topic == "limit" then -- Set push limit
local nvm = techage.get_nvm(pos)
CRD(pos).State:stop(pos, nvm)
set_limit(pos, nvm, payload)
return true
elseif topic == "count" then -- Get number of push items
local nvm = techage.get_nvm(pos)
return nvm.num_items or 0
else
return CRD(pos).State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
if topic == 65 then -- Set item type
local nvm = techage.get_nvm(pos)
CRD(pos).State:stop(pos, nvm)
config_item(pos, payload)
return 0
elseif topic == 68 or topic == 20 then -- Set push limit
local nvm = techage.get_nvm(pos)
CRD(pos).State:stop(pos, nvm)
set_limit(pos, nvm, payload[1])
return 0
else
local nvm = techage.get_nvm(pos)
if nvm.limit then
nvm.num_items = 0
end
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 150 then -- Get number of pushed items
local nvm = techage.get_nvm(pos)
return 0, {nvm.num_items or 0}
else
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end
end,
}
local node_name_ta2, node_name_ta3, node_name_ta4 =
@ -265,6 +372,7 @@ local node_name_ta2, node_name_ta3, node_name_ta4 =
formspec = ta4_formspec,
tubing = tubing,
can_start = can_start,
on_state_change = on_state_change,
after_place_node = function(pos, placer)
local meta = M(pos)
local node = minetest.get_node(pos)
@ -292,6 +400,8 @@ local node_name_ta2, node_name_ta3, node_name_ta4 =
node_timer = keep_running,
on_rotate = screwdriver.disallow,
tubelib2_on_update2 = tubelib2_on_update2,
ta4_formspec = WRENCH_MENU,
ta_after_formspec = ta_after_formspec,
groups = {choppy=2, cracky=2, crumbly=2},
is_ground_content = false,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -26,16 +26,16 @@ local CRD = function(pos) return (minetest.registered_nodes[techage.get_node_lvm
local S = techage.S
local CYCLE_TIME = 3
local CYCLE_TIME = 4
local STANDBY_TICKS = 4
local COUNTDOWN_TICKS = 4
local Side2Facedir = {F=0, R=1, B=2, L=3, D=4, U=5}
local Depth2Idx = {[1]=1 ,[2]=2, [3]=3, [5]=4, [10]=5, [15]=6, [20]=7, [25]=8, [40]=9, [60]=10, [80]=11}
local Depth2Idx = {[1]=1 ,[2]=2, [3]=3, [5]=4, [7]=5, [10]=6, [15]=7, [20]=8, [25]=9, [40]=10, [60]=11, [80]=12}
local Holesize2Idx = {["3x3"] = 1, ["5x5"] = 2, ["7x7"] = 3, ["9x9"] = 4, ["11x11"] = 5}
local Holesize2Diameter = {["3x3"] = 3, ["5x5"] = 5, ["7x7"] = 7, ["9x9"] = 9, ["11x11"] = 11}
local Level2Idx = {[2]=1, [1]=2, [0]=3, [-1]=4, [-2]=5, [-3]=6,
[-5]=7, [-10]=8, [-15]=9, [-20]=10}
[-5]=7, [-10]=8, [-15]=9, [-20]=10}
local function formspec(self, pos, nvm)
local tooltip = S("Start level = 0\nmeans the same level\nas the quarry is placed")
@ -46,12 +46,14 @@ local function formspec(self, pos, nvm)
local hsize_list = "5x5"
if CRD(pos).stage == 4 then
hsize_list = "3x3,5x5,7x7,9x9,11x11"
elseif CRD(pos).stage == 3 then
hsize_list = "3x3,5x5,7x7"
end
local depth_list = "1,2,3,5,10,15,20,25,40,60,80"
local depth_list = "1,2,3,5,7,10,15,20,25,40,60,80"
if CRD(pos).stage == 3 then
depth_list = "1,2,3,5,10,15,20,25,40"
depth_list = "1,2,3,5,7,10,15,20,25,40"
elseif CRD(pos).stage == 2 then
depth_list = "1,2,3,5,10,15,20"
depth_list = "1,2,3,5,7,10,15,20"
end
return "size[8,8]"..
@ -196,6 +198,9 @@ local function quarry_task(pos, crd, nvm)
pos1.y = y_curr
pos2.y = y_curr
-- Restarting the server can detach the coroutine data.
-- Therefore, read nvm again.
nvm = techage.get_nvm(pos)
nvm.level = y_first - y_curr
if minetest.is_area_protected(pos1, pos2, owner, 5) then
@ -205,6 +210,7 @@ local function quarry_task(pos, crd, nvm)
if not is_air_level(pos1, pos2, nvm.hole_diameter) then
mark_area(pos1, pos2, owner)
M(pos):set_string("formspec", formspec(CRD(pos).State, pos, nvm))
coroutine.yield()
for zoffs = 1, nvm.hole_diameter do
@ -237,7 +243,7 @@ local function keep_running(pos, elapsed)
local crd = CRD(pos)
local _, err = coroutine.resume(mem.co, pos, crd, nvm)
if err then
minetest.log("error", "[TA4 Quarry Coroutine Error]" .. err)
minetest.log("error", "[TA4 Quarry Coroutine Error] at pos " .. minetest.pos_to_string(pos) .. " " .. err)
end
if techage.is_activeformspec(pos) then
@ -298,6 +304,13 @@ local function on_receive_fields(pos, formname, fields, player)
mem.co = nil
CRD(pos).State:stop(pos, nvm)
end
elseif CRD(pos).stage == 3 then
if fields.hole_size ~= nvm.hole_size then
nvm.hole_size = fields.hole_size
nvm.hole_diameter = Holesize2Diameter[fields.hole_size or "7x7"] or 7
mem.co = nil
CRD(pos).State:stop(pos, nvm)
end
else
nvm.hole_size = "5x5"
nvm.hole_diameter = 5
@ -324,7 +337,7 @@ tiles.act = {
"techage_filling_ta#.png^techage_frame_ta#.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_outp.png",
{
image = "techage_frame14_ta#.png^techage_quarry_left14.png",
name = "techage_frame14_ta#.png^techage_quarry_left14.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -368,8 +381,24 @@ local tubing = {
return CRD(pos).State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 133 then -- Quarry Depth
local nvm = techage.get_nvm(pos)
return 0, {nvm.level or 0}
else
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
local nvm = techage.get_nvm(pos)
if nvm.techage_state == techage.RUNNING then
stop_sound(pos)
play_sound(pos)
end
end,
}

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -45,7 +45,7 @@ local SpecialItems = {
["dye:black"] = "",
["techage:basalt_glass_thin"] = "",
["group:stone"] = "techage:sieved_gravel",
["basic_materials:plastic_sheet"] = "",
--["basic_materials:plastic_sheet"] = "",
["group:wood"] = "default:stick 5",
["techage:basalt_glass"] = "",
["default:junglewood"] = "default:stick 5",
@ -115,7 +115,7 @@ end
local function cook_reverse(stack, inv, idx, recipe)
-- check space
for _,item in ipairs(recipe.items) do
if not inv:room_for_item("dst", stack) then
if not inv:room_for_item("dst", item) then
return false
end
end
@ -193,7 +193,7 @@ tiles.pas = {
tiles.act = {
-- up, down, right, left, back, front
{
image = "techage_appl_grinder4.png^[colorize:@@000000:100^techage_frame4_ta#_top.png",
name = "techage_appl_grinder4.png^[colorize:@@000000:100^techage_frame4_ta#_top.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -235,6 +235,12 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
return CRD(pos).State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
end,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2020 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -22,6 +22,7 @@ local STACK_SIZE = 2000
local function gen_stack(inv, idx)
inv[idx] = {name = "", count = 0}
return inv[idx]
end
local function gen_inv(nvm)
@ -92,6 +93,18 @@ local function inv_state(nvm)
return "loaded"
end
local function inv_state_num(nvm)
local num = 0
for _,item in ipairs(nvm.inventory or {}) do
if item.count and item.count > 0 then
num = num + 1
end
end
if num == 0 then return 0 end
if num == 8 then return 2 end
return 1
end
local function max_stacksize(item_name)
-- It is sufficient to use minetest.registered_items as all registration
-- functions (node, craftitems, tools) add the definitions there.
@ -121,7 +134,7 @@ local function doesItemStackMatchNvmStack(itemstack, nvmstack)
-- The following seems to be the most reliable approach to compare meta.
local nvm_meta = ItemStack():get_meta()
nvm_meta:from_table(minetest.deserialize(nvmstack.meta))
nvm_meta:from_table(minetest.deserialize(nvmstack.meta or ""))
if not nvm_meta:equals(itemstack:get_meta()) then
return false, "Mismatching meta"
end
@ -185,7 +198,7 @@ local function take_from_chest(pos, idx, output_stack, max_total_count, keep_ass
count = count,
wear = nvm_stack.wear,
}))
output_stack:get_meta():from_table(minetest.deserialize(nvm_stack.meta))
output_stack:get_meta():from_table(minetest.deserialize(nvm_stack.meta or ""))
nvm_stack.count = nvm_stack.count - count
if nvm_stack.count == 0 then
gen_stack(nvm.inventory or {}, idx)
@ -198,21 +211,14 @@ local function tube_add_to_chest(pos, input_stack)
local nvm = techage.get_nvm(pos)
nvm.inventory = nvm.inventory or {}
-- Backup some values needed for restoring the old
-- state if items can't fully be added to chest.
local orig_count = input_stack:get_count()
local backup = table.copy(nvm.inventory)
for idx = 1,8 do
input_stack:take_item(add_to_chest(pos, input_stack, idx))
end
if input_stack:get_count() > 0 then
nvm.inventory = backup -- Restore old nvm inventory
input_stack:set_count(orig_count) -- Restore input_stack
return false -- No items were added to chest
return input_stack -- Not all items were added to chest
else
return true -- Items were added successfully
return true -- All items were added
end
end
@ -324,31 +330,55 @@ local function count_number_of_chests(pos)
local node = techage.get_node_lvm(pos)
local dir = techage.side_to_outdir("B", node.param2)
local pos1 = tubelib2.get_pos(pos, dir)
local param2 = node.param2
local cnt = 1
while cnt < 50 do
node = techage.get_node_lvm(pos1)
if node.name ~= "techage:ta4_chest_dummy" then
break
end
local meta = M(pos1)
if meta:contains("param2") and meta:get_int("param2") ~= param2 then
break
end
pos1 = tubelib2.get_pos(pos1, dir)
cnt = cnt + 1
end
M(pos):set_int("stacksize", STACK_SIZE * cnt)
end
local function dummy_chest_behind(pos, node)
local dir = techage.side_to_outdir("B", node.param2)
local pos1 = tubelib2.get_pos(pos, dir)
node = techage.get_node_lvm(pos1)
return node.name == "techage:ta4_chest_dummy"
end
local function part_of_a_chain(pos, node)
local dir = techage.side_to_outdir("F", node.param2)
local pos1 = tubelib2.get_pos(pos, dir)
node = techage.get_node_lvm(pos1)
return node.name == "techage:ta4_chest_dummy" or node.name == "techage:ta4_chest"
end
local function search_chest_in_front(pos, node)
local dir = techage.side_to_outdir("F", node.param2)
local pos1 = tubelib2.get_pos(pos, dir)
local param2 = node.param2
local cnt = 1
while cnt < 50 do
node = techage.get_node_lvm(pos1)
if node.name ~= "techage:ta4_chest_dummy" then
break
end
local meta = M(pos1)
if meta:contains("param2") and meta:get_int("param2") ~= param2 then
break
end
pos1 = tubelib2.get_pos(pos1, dir)
cnt = cnt + 1
end
if node.name == "techage:ta4_chest" then
if node.name == "techage:ta4_chest" and node.param2 == param2 then
minetest.after(1, count_number_of_chests, pos1)
local nvm = techage.get_nvm(pos)
nvm.front_chest_pos = pos1
@ -514,9 +544,14 @@ minetest.register_node("techage:ta4_chest", {
after_place_node = function(pos, placer)
local node = minetest.get_node(pos)
if dummy_chest_behind(pos, node) then
minetest.remove_node(pos)
return true
end
if search_chest_in_front(pos, node) then
node.name = "techage:ta4_chest_dummy"
minetest.swap_node(pos, node)
M(pos):set_int("param2", node.param2)
else
local nvm = techage.get_nvm(pos)
gen_inv(nvm)
@ -597,10 +632,12 @@ techage.register_node({"techage:ta4_chest"}, {
on_recv_message = function(pos, src, topic, payload)
if topic == "count" then
local nvm = techage.get_nvm(pos)
return get_count(nvm, tonumber(payload) or 0)
return get_count(nvm, tonumber(payload or 0) or 0)
elseif topic == "itemstring" then
local nvm = techage.get_nvm(pos)
return get_itemstring(nvm, tonumber(payload) or 0)
return get_itemstring(nvm, tonumber(payload or 0) or 0)
elseif topic == "storesize" then
return get_stacksize(pos)
elseif topic == "state" then
local nvm = techage.get_nvm(pos)
return inv_state(nvm)
@ -608,6 +645,22 @@ techage.register_node({"techage:ta4_chest"}, {
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 140 and payload[1] == 1 then -- Inventory Item Count
local nvm = techage.get_nvm(pos)
return 0, {get_count(nvm, tonumber(payload[2] or 0) or 0)}
elseif topic == 140 and payload[1] == 2 then -- Inventory Item Name
local nvm = techage.get_nvm(pos)
return 0, get_itemstring(nvm, tonumber(payload[2] or 0) or 0)
elseif topic == 140 and payload[1] == 3 then -- storesize
return 0, {get_stacksize(pos)}
elseif topic == 131 then -- Chest State
local nvm = techage.get_nvm(pos)
return 0, {inv_state_num(nvm)}
else
return 2, ""
end
end,
})
techage.register_node({"techage:ta4_chest_dummy"}, {
@ -637,6 +690,18 @@ techage.register_node({"techage:ta4_chest_dummy"}, {
end
})
minetest.register_lbm({
label = "Repair Dummy Chests",
name = "techage:chest_dummy",
nodenames = {"techage:ta4_chest_dummy"},
run_at_every_load = true,
action = function(pos, node)
if not part_of_a_chain(pos, node) then
minetest.swap_node(pos, {name = "techage:ta4_chest", param2 = node.param2})
end
end,
})
minetest.register_craft({
type = "shapeless",
output = "techage:ta4_chest",

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2020 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -19,6 +19,7 @@ local S = techage.S
-- Consumer Related Data
local CRD = function(pos) return (minetest.registered_nodes[techage.get_node_lvm(pos).name] or {}).consumer end
local tooltip = S("Switch to pull mode \nto pull items out of inventory slots \naccording the injector configuration")
local Tube = techage.Tube
local STANDBY_TICKS = 2
local COUNTDOWN_TICKS = 3
@ -121,8 +122,23 @@ local function push_items(pos, out_dir, idx, items)
return true
end
end
return false
else
return techage.push_items(pos, out_dir, items, idx)
local taken = items:get_count()
local leftover = techage.push_items(pos, out_dir, items, idx)
if not leftover or leftover == false then
return false -- No items placed
elseif leftover ~= true then
-- One or more items placed?
if leftover:get_count() < taken then
-- place the rest back
local pull_dir = M(pos):get_int("pull_dir")
techage.unpull_items(pos, pull_dir, leftover)
return true -- Some items placed
end
return false -- No items placed
end
return true -- All items placed
end
end
@ -198,7 +214,7 @@ local tiles = {}
-- '{power}' will be replaced by the power PNG
tiles.pas = {
"techage_filling_ta#.png^techage_frame_ta#_top.png^techage_appl_arrow.png",
"techage_filling_ta#.png^techage_frame_ta#.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_arrow.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_outp.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_inp.png",
"techage_appl_pusher.png^[transformR180]^techage_frame_ta#.png^techage_appl_injector.png",
@ -207,11 +223,11 @@ tiles.pas = {
tiles.act = {
-- up, down, right, left, back, front
"techage_filling_ta#.png^techage_frame_ta#_top.png^techage_appl_arrow.png",
"techage_filling_ta#.png^techage_frame_ta#.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_arrow.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_outp.png",
"techage_filling_ta#.png^techage_frame_ta#.png^techage_appl_inp.png",
{
image = "techage_appl_pusher14.png^[transformR180]^techage_frame14_ta#.png^techage_appl_injector14.png",
name = "techage_appl_pusher14.png^[transformR180]^techage_frame14_ta#.png^techage_appl_injector14.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -221,7 +237,7 @@ tiles.act = {
},
},
{
image = "techage_appl_pusher14.png^techage_frame14_ta#.png^techage_appl_injector14.png",
name = "techage_appl_pusher14.png^techage_frame14_ta#.png^techage_appl_injector14.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -242,6 +258,12 @@ local tubing = {
on_recv_message = function(pos, src, topic, payload)
return CRD(pos).State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end,
on_node_load = function(pos)
CRD(pos).State:on_node_load(pos)
end,
@ -264,6 +286,18 @@ local _, node_name_ta3, node_name_ta4 =
local nvm = techage.get_nvm(pos)
M(pos):set_string("formspec", formspec(CRD(pos).State, pos, nvm))
end,
ta_rotate_node = function(pos, node, new_param2)
local nvm = techage.get_nvm(pos)
if CRD(pos).State:get_state(nvm) == techage.STOPPED then
Tube:after_dig_node(pos)
minetest.swap_node(pos, {name = node.name, param2 = new_param2})
Tube:after_place_node(pos)
local meta = M(pos)
meta:set_int("pull_dir", techage.side_to_outdir("L", new_param2))
meta:set_int("push_dir", techage.side_to_outdir("R", new_param2))
M(pos):set_string("formspec", formspec(CRD(pos).State, pos, nvm))
end
end,
allow_metadata_inventory_put = allow_metadata_inventory_put,
allow_metadata_inventory_take = allow_metadata_inventory_take,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2022 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -19,7 +19,7 @@ local M = minetest.get_meta
local S = techage.S
local TA4_INV_SIZE = 32
local EX_POINTS = 20
local EX_POINTS = 15
local hyperloop = techage.hyperloop
local remote_pos = techage.hyperloop.remote_pos
@ -29,7 +29,7 @@ local menu = techage.menu
local function formspec(pos)
local ndef = minetest.registered_nodes["techage:ta5_hl_chest"]
local status = M(pos):get_string("conn_status")
if hyperloop.is_client(pos) or hyperloop.is_server(pos) then
if hyperloop.is_server(pos) then
local title = ndef.description .. " " .. status
return "size[8,9]"..
"box[0,-0.1;7.8,0.5;#c6e8ff]" ..
@ -38,6 +38,13 @@ local function formspec(pos)
"list[current_player;main;0,5.3;8,4;]"..
"listring[context;main]"..
"listring[current_player;main]"
elseif hyperloop.is_client(pos) then
local title = ndef.description .. " " .. status
return "size[8,9]"..
"box[0,-0.1;7.8,0.5;#c6e8ff]" ..
"label[0.2,-0.1;" .. minetest.colorize( "#000000", title) .. "]" ..
"label[0.2,2;Inventory access on this node is disabled\ndue to minetest engine issues!]" ..
"list[current_player;main;0,5.3;8,4;]"
else
return menu.generate_formspec(pos, ndef, hyperloop.SUBMENU)
end
@ -47,9 +54,12 @@ local function allow_metadata_inventory_put(pos, listname, index, stack, player)
if minetest.is_protected(pos, player:get_player_name()) then
return 0
end
if techage.hyperloop.is_client(pos) then
return 0
end
shared_inv.before_inv_access(pos, listname)
local inv = minetest.get_inventory({type="node", pos=pos})
if inv:room_for_item(listname, stack) then
if inv and inv:room_for_item(listname, stack) then
return stack:get_count()
end
return 0
@ -59,9 +69,12 @@ local function allow_metadata_inventory_take(pos, listname, index, stack, player
if minetest.is_protected(pos, player:get_player_name()) then
return 0
end
if techage.hyperloop.is_client(pos) then
return 0
end
shared_inv.before_inv_access(pos, listname)
local inv = minetest.get_inventory({type="node", pos=pos})
if inv:contains_item(listname, stack) then
if inv and inv:contains_item(listname, stack) then
return stack:get_count()
end
return 0
@ -71,6 +84,9 @@ local function allow_metadata_inventory_move(pos, from_list, from_index, to_list
if shared_inv.before_inv_access(pos, "main") then
return 0
end
if techage.hyperloop.is_client(pos) then
return 0
end
return count
end
@ -141,40 +157,81 @@ minetest.register_node("techage:ta5_hl_chest", {
techage.register_node({"techage:ta5_hl_chest"}, {
on_inv_request = function(pos, in_dir, access_type)
pos = remote_pos(pos)
local meta = minetest.get_meta(pos)
return meta:get_inventory(), "main"
if pos then
local meta = minetest.get_meta(pos)
if meta then
return meta:get_inventory(), "main"
end
end
end,
on_pull_item = function(pos, in_dir, num, item_name)
pos = remote_pos(pos)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.get_items(pos, inv, "main", num)
if pos then
local meta = minetest.get_meta(pos)
if meta then
local inv = meta:get_inventory()
if inv then
return techage.get_items(pos, inv, "main", num)
end
end
end
return false
end,
on_push_item = function(pos, in_dir, stack)
if techage.hyperloop.is_paired(pos) then
pos = remote_pos(pos)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.put_items(inv, "main", stack)
if pos then
local meta = minetest.get_meta(pos)
if meta then
local inv = meta:get_inventory()
if inv then
return techage.put_items(inv, "main", stack)
end
end
end
end
return false
end,
on_unpull_item = function(pos, in_dir, stack)
pos = remote_pos(pos)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.put_items(inv, "main", stack)
if pos then
local meta = minetest.get_meta(pos)
if meta then
local inv = meta:get_inventory()
if inv then
return techage.put_items(inv, "main", stack)
end
end
end
return false
end,
on_recv_message = function(pos, src, topic, payload)
if topic == "state" then
pos = remote_pos(pos)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.get_inv_state(inv, "main")
if meta then
local inv = meta:get_inventory()
if inv then
return techage.get_inv_state(inv, "main")
end
end
return "error"
else
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 131 then -- Chest State
local meta = minetest.get_meta(pos)
if meta then
local inv = meta:get_inventory()
if inv then
return 0, {techage.get_inv_state_num(inv, "main")}
end
end
else
return 2, ""
end
end,
})
@ -183,3 +240,9 @@ minetest.register_craft({
output = "techage:ta5_hl_chest",
recipe = {"techage:chest_ta4", "techage:ta5_aichip"}
})
minetest.register_on_mods_loaded(function()
if not minetest.global_exists("hyperloop") then
minetest.clear_craft({output = "techage:ta5_hl_chest"})
end
end)

View File

@ -173,13 +173,14 @@ local function remove_inv(pos, inv, param2, AssemblyPlan, player_name, idx)
if inv:room_for_item("src", stack) then
local node = minetest.get_node(pos1)
if node.name == node_name then
local meta = M(pos1):to_table()
minetest.remove_node(pos1)
inv:add_item("src", stack)
play_sound(pos, "default_dig_cracky")
local ndef = minetest.registered_nodes[node_name]
if ndef and ndef.after_dig_node then
local digger = minetest.get_player_by_name(player_name)
ndef.after_dig_node(pos1, pos, ItemStack(node_name), {}, digger)
ndef.after_dig_node(pos1, node, meta, digger)
end
end
end

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -24,13 +24,10 @@ local BLOCKING_TIME = 0.3 -- 300ms
techage.boiler = {}
local IsWater = {
["bucket:bucket_river_water"] = true,
["bucket:bucket_water"] = true,
["bucket:bucket_river_water"] = "bucket:bucket_empty",
}
local IsBucket = {
["bucket:bucket_empty"] = true,
}
local IsBucket = {}
local function node_description(name)
name = string.split(name, " ")[1]
@ -126,12 +123,12 @@ function techage.boiler.on_punch(pos, node, puncher, pointed_thing)
if IsWater[wielded_item] and nvm.num_water < MAX_WATER then
mem.blocking_time = techage.SystemTime + BLOCKING_TIME
nvm.num_water = nvm.num_water + 1
puncher:set_wielded_item(ItemStack("bucket:bucket_empty"))
puncher:set_wielded_item(ItemStack(IsWater[wielded_item]))
M(pos):set_string("formspec", techage.boiler.formspec(pos, nvm))
elseif IsBucket[wielded_item] and nvm.num_water > 0 then
if item_count > 1 then
local inv = puncher:get_inventory()
local item = ItemStack("bucket:bucket_water")
local item = ItemStack(IsBucket[wielded_item])
if inv:room_for_item("main", item) then
inv:add_item("main", item)
puncher:set_wielded_item({name=wielded_item, count = item_count - 1})
@ -141,8 +138,13 @@ function techage.boiler.on_punch(pos, node, puncher, pointed_thing)
else
mem.blocking_time = techage.SystemTime + BLOCKING_TIME
nvm.num_water = nvm.num_water - 1
puncher:set_wielded_item(ItemStack("bucket:bucket_water"))
puncher:set_wielded_item(ItemStack(IsBucket[wielded_item]))
end
M(pos):set_string("formspec", techage.boiler.formspec(pos, nvm))
end
end
function techage.register_water_bucket(empty_bucket, full_bucket)
IsWater[full_bucket] = empty_bucket
IsBucket[empty_bucket] = full_bucket
end

View File

@ -16,6 +16,7 @@
local S = function(pos) if pos then return minetest.pos_to_string(pos) end end
--local P = minetest.string_to_pos
--local M = minetest.get_meta
local has_mesecons = minetest.global_exists("mesecon")
local NodeInfoCache = {}
local NumbersToBeRecycled = {}
@ -171,7 +172,7 @@ end)
techage.dug_node = {}
minetest.register_on_dignode(function(pos, oldnode, digger)
if not digger then return end
-- store pos for tools without own 'register_on_dignode'
-- store the position of the dug block for tools like the TA1 hammer
techage.dug_node[digger:get_player_name()] = pos
end)
@ -179,6 +180,14 @@ end)
-- API helper functions
-------------------------------------------------------------------
-- Check if both strings are the same or one string starts with the other string.
function techage.string_compare(s1, s2)
if s1 and s2 then
local minLength = math.min(#s1, #s2)
return string.sub(s1, 1, minLength) == string.sub(s2, 1, minLength)
end
end
-- Function returns { pos, name } for the node referenced by number
function techage.get_node_info(dest_num)
return NodeInfoCache[dest_num] or update_nodeinfo(dest_num)
@ -230,6 +239,7 @@ function techage.add_node(pos, name, is_ta2)
local key = minetest.hash_node_position(pos)
local num = NumbersToBeRecycled[key]
if num then
NodeInfoCache[num] = nil
backend.set_nodepos(num, pos)
NumbersToBeRecycled[key] = nil
return num
@ -281,6 +291,18 @@ function techage.pack_node(pos, oldnode, number)
end
end
-------------------------------------------------------------------
-- Used by the assembly tool
-------------------------------------------------------------------
function techage.pre_add_node(pos, number)
local key = minetest.hash_node_position(pos)
NumbersToBeRecycled[key] = number
end
function techage.post_remove_node(pos)
local key = minetest.hash_node_position(pos)
NumbersToBeRecycled[key] = nil
end
-------------------------------------------------------------------
-- Node register function
@ -316,6 +338,13 @@ function techage.register_node(names, node_definition)
if node_definition.on_node_load then
register_lbm(names[1], names)
end
-- register mvps stopper
if has_mesecons then
for _, name in ipairs(names) do
mesecon.register_mvps_stopper(name)
end
end
end
-------------------------------------------------------------------
@ -330,6 +359,19 @@ function techage.not_protected(number, placer_name, clicker_name)
return false
end
-- Check the given number value.
-- Returns true if the number is valid, point to real node and
-- and the node is not protected for the given player_name.
function techage.check_number(number, placer_name)
if number then
if not techage.not_protected(number, placer_name, nil) then
return false
end
return true
end
return false
end
-- Check the given list of numbers.
-- Returns true if number(s) is/are valid, point to real nodes and
-- and the nodes are not protected for the given player_name.
@ -406,6 +448,35 @@ function techage.transfer(pos, outdir, topic, payload, network, nodenames)
return false
end
-------------------------------------------------------------------
-- Beduino functions (see "bep-005_ta_cmnd.md")
-------------------------------------------------------------------
function techage.beduino_send_cmnd(src, number, topic, payload)
--print("beduino_send_cmnd", src, number, topic)
local ninfo = NodeInfoCache[number] or update_nodeinfo(number)
if ninfo and ninfo.name and ninfo.pos then
local ndef = NodeDef[ninfo.name]
if ndef and ndef.on_beduino_receive_cmnd then
techage_counting_hit()
return ndef.on_beduino_receive_cmnd(ninfo.pos, src, topic, payload or {})
end
end
return 1, ""
end
function techage.beduino_request_data(src, number, topic, payload)
--print("beduino_request_data", src, number, topic)
local ninfo = NodeInfoCache[number] or update_nodeinfo(number)
if ninfo and ninfo.name and ninfo.pos then
local ndef = NodeDef[ninfo.name]
if ndef and ndef.on_beduino_request_data then
techage_counting_hit()
return ndef.on_beduino_request_data(ninfo.pos, src, topic, payload or {})
end
end
return 1, ""
end
-------------------------------------------------------------------
-- Client side Push/Pull item functions
-------------------------------------------------------------------
@ -432,7 +503,7 @@ function techage.push_items(pos, out_dir, stack, idx)
minetest.add_item(npos, stack)
return true
end
return false
return stack
end
-- Check for recursion and too long distances
@ -457,7 +528,7 @@ function techage.safe_push_items(pos, out_dir, stack, idx)
end
end
end
return false
return stack
end
function techage.unpull_items(pos, out_dir, stack)
@ -468,37 +539,6 @@ function techage.unpull_items(pos, out_dir, stack)
return false
end
-------------------------------------------------------------------
-- Client side Push/Pull item functions for hopper like nodes
-- (nodes with no tube support)
-------------------------------------------------------------------
function techage.neighbour_pull_items(pos, out_dir, num)
local res, npos, in_dir, name = get_next_node(pos, out_dir)
if res and NodeDef[name] and NodeDef[name].on_pull_item then
return NodeDef[name].on_pull_item(npos, in_dir, num)
end
end
function techage.neighbour_push_items(pos, out_dir, stack)
local res, npos, in_dir, name = get_next_node(pos, out_dir)
if res and NodeDef[name] and NodeDef[name].on_push_item then
return NodeDef[name].on_push_item(npos, in_dir, stack)
elseif name == "air" then
minetest.add_item(npos, stack)
return true
end
return false
end
function techage.neighbour_unpull_items(pos, out_dir, stack)
local res, npos, in_dir, name = get_next_node(pos, out_dir)
if res and NodeDef[name] and NodeDef[name].on_unpull_item then
return NodeDef[name].on_unpull_item(npos, in_dir, stack)
end
return false
end
-------------------------------------------------------------------
-- Server side helper functions
-------------------------------------------------------------------
@ -526,23 +566,33 @@ function techage.get_items(pos, inv, listname, num)
return nil
end
-- Put the given stack into the given ItemList.
-- Function returns false if ItemList is full.
-- Put the given stack into the given ItemList/inventory.
-- Function returns:
-- - true, if all items are moved
-- - false, if no item is moved
-- - leftover, if less than all items are moved
-- (true/false is the legacy mode and can't be removed)
function techage.put_items(inv, listname, item, idx)
local leftover
if idx and inv and idx <= inv:get_size(listname) then
local stack = inv:get_stack(listname, idx)
if stack:item_fits(item) then
stack:add_item(item)
inv:set_stack(listname, idx, stack)
return true
end
leftover = stack:add_item(item)
inv:set_stack(listname, idx, stack)
elseif inv then
leftover = inv:add_item(listname, item)
else
if inv and inv:room_for_item(listname, item) then
inv:add_item(listname, item)
return true
end
return false
end
return false
local cnt = leftover:get_count()
if cnt == item:get_count() then
return false
elseif cnt == 0 then
return true
else
return leftover
end
end
-- Return "full", "loaded", or "empty" depending
@ -564,6 +614,23 @@ function techage.get_inv_state(inv, listname)
return state
end
-- Beduino variant
function techage.get_inv_state_num(inv, listname)
local state
if inv:is_empty(listname) then
state = 0
else
local list = inv:get_list(listname)
state = 2
for _, item in ipairs(list) do
if item:is_empty() then
return 1
end
end
end
return state
end
minetest.register_chatcommand("ta_send", {
description = minetest.formspec_escape(
"Send a techage command to the block with the number given: /ta_send <number> <command> [<data>]"),

View File

@ -10,9 +10,12 @@
Configured inventory lib
Assuming the inventory has the name "conf"
Otherwise the name has to be provided as argument
]]--
local StackName = ... or "conf"
-- for lazy programmers
local M = minetest.get_meta
@ -22,7 +25,7 @@ function inv_lib.preassigned_stacks(pos, xsize, ysize)
local inv = M(pos):get_inventory()
local tbl = {}
for idx = 1, xsize * ysize do
local item_name = inv:get_stack("conf", idx):get_name()
local item_name = inv:get_stack(StackName, idx):get_name()
if item_name ~= "" then
local x = (idx - 1) % xsize
local y = math.floor((idx - 1) / xsize)
@ -36,7 +39,7 @@ function inv_lib.item_filter(pos, size)
local inv = M(pos):get_inventory()
local filter = {}
for idx = 1, size do
local item_name = inv:get_stack("conf", idx):get_name()
local item_name = inv:get_stack(StackName, idx):get_name()
if item_name == "" then item_name = "unconfigured" end
if not filter[item_name] then
filter[item_name] = {}
@ -76,16 +79,22 @@ function inv_lib.allow_conf_inv_move(pos, from_list, from_index, to_list, to_ind
end
function inv_lib.put_items(pos, inv, listname, item, stacks, idx)
local name = item:get_name()
local count = item:get_count()
for _, i in ipairs(stacks or {}) do
if not idx or idx == i then
local stack = inv:get_stack(listname, i)
if stack:item_fits(item) then
stack:add_item(item)
inv:set_stack(listname, i, stack)
local leftover = stack:add_item({name = name, count = count})
count = leftover:get_count()
inv:set_stack(listname, i, stack)
if count == 0 then
return true
end
end
end
if count > 0 then
return ItemStack({name = name, count = count})
end
return false
end

View File

@ -20,14 +20,14 @@ local S = techage.S
techage.firebox = {}
techage.firebox.Burntime = {
["techage:charcoal"] = true, -- will be replaced by burntime
["default:coal_lump"] = true,
["default:coalblock"] = true,
["techage:oil_source"] = true,
["techage:gas"] = true,
["techage:gasoline"] = true,
["techage:naphtha"] = true,
["techage:fueloil"] = true,
["techage:charcoal"] = 1, -- will be replaced by burntime
["default:coal_lump"] = 1,
["default:coalblock"] = 1,
["techage:oil_source"] = 1,
["techage:gas"] = 1,
["techage:gasoline"] = 1,
["techage:naphtha"] = 1,
["techage:fueloil"] = 1,
}
techage.firebox.ValidOilFuels = {
@ -44,7 +44,7 @@ local function determine_burntimes()
techage.firebox.Burntime[k] = fuel.time
end
end
minetest.after(1, determine_burntimes)
minetest.register_on_mods_loaded(determine_burntimes)
function techage.firebox.formspec(nvm)
local fuel_percent = 0

File diff suppressed because it is too large Load Diff

View File

@ -29,7 +29,7 @@ local ProbabilityCorrections = {
-- collect all registered ores and calculate the probability
local function add_ores()
for _,item in pairs(minetest.registered_ores) do
if minetest.registered_nodes[item.ore] then
if not ore_probability[item.ore] and minetest.registered_nodes[item.ore] then
local drop = minetest.registered_nodes[item.ore].drop
if type(drop) == "string"
and drop ~= item.ore
@ -66,8 +66,14 @@ local function add_ores()
minetest.log("info", string.format("[techage] Overall probability %g", overall_probability))
end
minetest.after(1, add_ores)
minetest.register_on_mods_loaded(add_ores)
--
-- Change the probability of ores or register new ores for sieving
--
function techage.register_ore_for_gravelsieve(ore_name, probability)
ore_probability[ore_name] = probability
end
-- determine ore based on the calculated probability
function techage.gravelsieve_get_random_gravel_ore()

View File

@ -57,16 +57,19 @@ local function get_remote_pos(pos, rmt_name)
end
local function get_free_server_list(pos, owner)
local tbl = {M(pos):get_string("remote_name")}
for key,item in pairs(Stations:get_node_table(pos)) do
if item.single and item.owner == owner then
if M(pos):get_string("node_type") == M(S2P(key)):get_string("node_type") then
tbl[#tbl+1] = item.conn_name
if Stations and Stations.get_node_table then
local tbl = {M(pos):get_string("remote_name")}
for key,item in pairs(Stations:get_node_table(pos) or {}) do
if item.single and item.owner == owner then
if M(pos):get_string("node_type") == M(S2P(key)):get_string("node_type") then
tbl[#tbl+1] = item.conn_name
end
end
end
tbl[#tbl+1] = ""
return tbl
end
tbl[#tbl+1] = ""
return tbl
return {}
end
local function on_lose_connection(pos, node_type)
@ -78,8 +81,11 @@ local function on_lose_connection(pos, node_type)
end
local function on_dropdown(pos)
local owner = M(pos):get_string("owner")
return table.concat(get_free_server_list(pos, owner), ",")
if pos then
local owner = M(pos):get_string("owner")
return table.concat(get_free_server_list(pos, owner), ",") or ""
end
return ""
end
local function update_node_data(pos, state, conn_name, remote_name, rmt_pos)
@ -178,7 +184,7 @@ function techage.hyperloop.remote_pos(pos)
local nvm = techage.get_nvm(pos)
if Stations:get(nvm.rmt_pos) then
if M(pos):contains("remote_name") then
return nvm.rmt_pos
return nvm.rmt_pos or pos
end
end
end

View File

@ -76,7 +76,7 @@ for _,row in ipairs(ROTATION) do
end
function techage.facedir_to_rotation(facedir)
return FACEDIR_TO_ROT[facedir]
return FACEDIR_TO_ROT[facedir] or FACEDIR_TO_ROT[0]
end
function techage.param2_turn_left(param2)
@ -129,7 +129,6 @@ function techage.param2_turn_up(facedir, param2)
end
-------------------------------------------------------------------------------
-- Rotate nodes around the center
-------------------------------------------------------------------------------
@ -181,12 +180,12 @@ function techage.rotate_around_center(nodes1, turn, cpos)
return nodes2
end
-- allowed for digging
local RegisteredNodesToBeDug = {}
function techage.register_node_to_be_dug(name)
RegisteredNodesToBeDug[name] = true
end
-------------------------------------------------------------------------------
-- Helper functions
-------------------------------------------------------------------------------
-- allowed for digging
local SimpleNodes = {}
-- translation from param2 to dir (out of the node upwards)
local Param2Dir = {}
@ -244,6 +243,17 @@ function techage.add_to_set(set, x)
end
end
-- techage.tbl_filter({"a", "b", "c", "d"}, function(v, k, t) return v >= "c" end) --> {"c","d"}
techage.tbl_filter = function(t, filterIter)
local out = {}
for k, v in pairs(t) do
if filterIter(v, k, t) then out[k] = v end
end
return out
end
function techage.get_node_lvm(pos)
local node = minetest.get_node_or_nil(pos)
if node then
@ -273,21 +283,54 @@ function techage.is_air_like(name)
end
-- returns true, if node can be dug, otherwise false
function techage.can_node_dig(node, ndef)
if RegisteredNodesToBeDug[node.name] then
function techage.can_dig_node(name, ndef)
if not ndef then return false end
if SimpleNodes[name] ~= nil then
return SimpleNodes[name]
end
if ndef.groups and ndef.groups.techage_door == 1 then
SimpleNodes[name] = true
return true
end
if not ndef then return false end
if node.name == "ignore" then return false end
if node.name == "air" then return true end
if ndef.buildable_to == true then return true end
if ndef.diggable == false then return false end
if ndef.after_dig_node then return false end
if name == "ignore" then
SimpleNodes[name] = false
return false
end
if name == "air" then
SimpleNodes[name] = true
return true
end
if ndef.buildable_to == true then
SimpleNodes[name] = true
return true
end
-- don't remove nodes with some intelligence or undiggable nodes
if ndef.drop == "" then
SimpleNodes[name] = false
return false
end
if ndef.diggable == false then
SimpleNodes[name] = false
return false
end
if ndef.after_dig_node then
SimpleNodes[name] = false
return false
end
-- add it to the white list
RegisteredNodesToBeDug[node.name] = true
SimpleNodes[name] = true
return true
end
-- Simple nodes
function techage.register_simple_nodes(node_names, is_valid)
if is_valid == nil then is_valid = true end
for _,name in ipairs(node_names or {}) do
SimpleNodes[name] = is_valid
end
end
techage.dig_states = {
NOT_DIGGABLE = 1,
INV_FULL = 2,
@ -421,50 +464,6 @@ function techage.item_image_small(x, y, itemname, tooltip_prefix)
tooltip
end
function techage.mydump(o, indent, nested, level)
local t = type(o)
if not level and t == "userdata" then
-- when userdata (e.g. player) is passed directly, print its metatable:
return "userdata metatable: " .. techage.mydump(getmetatable(o))
end
if t ~= "table" then
return basic_dump(o)
end
-- Contains table -> true/nil of currently nested tables
nested = nested or {}
if nested[o] then
return "<circular reference>"
end
nested[o] = true
indent = " "
level = level or 1
local t = {}
local dumped_indexes = {}
for i, v in ipairs(o) do
t[#t + 1] = techage.mydump(v, indent, nested, level + 1)
dumped_indexes[i] = true
end
for k, v in pairs(o) do
if not dumped_indexes[k] then
if type(k) ~= "string" or not is_valid_identifier(k) then
k = "["..techage.mydump(k, indent, nested, level + 1).."]"
end
v = techage.mydump(v, indent, nested, level + 1)
t[#t + 1] = k.." = "..v
end
end
nested[o] = nil
if indent ~= "" then
local indent_str = string.rep(indent, level)
local end_indent_str = string.rep(indent, level - 1)
return string.format("{%s%s%s}",
indent_str,
table.concat(t, ","..indent_str),
end_indent_str)
end
return "{"..table.concat(t, ", ").."}"
end
function techage.vector_dump(posses)
local t = {}
for _,pos in ipairs(posses) do
@ -482,7 +481,7 @@ end
function techage.wrench_tooltip(x, y)
local tooltip = S("Block has an\nadditional wrench menu")
return "label["..x..","..y..";"..minetest.colorize("#000000", minetest.formspec_escape("[?]")).."]"..
return "image["..x.."," .. y .. ";0.5,0.5;techage_inv_wrench.png]" ..
"tooltip["..x..","..y..";0.5,0.5;"..tooltip..";#0C3D32;#FFFFFF]"
end
@ -493,6 +492,10 @@ function techage.register_mobs_mods(mod)
techage.RegisteredMobsMods[mod] = true
end
function techage.beduino_signed_var(val)
val = val or 0
return val >= 32768 and val - 0x10000 or val
end
-------------------------------------------------------------------------------
-- Terminal history buffer
@ -561,6 +564,8 @@ function techage.add_expoint(player, number)
end
end
-- Delete number with: `//lua minetest.get_player_by_name("<name>"):get_meta():set_string("techage_collider_number", "")`
function techage.on_remove_collider(player)
if player and player.get_meta then
local meta = player:get_meta()

View File

@ -75,6 +75,24 @@ techage.liquid.recv_message = {
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 128 then
return 0, techage.get_node_lvm(pos).name
elseif topic == 134 then
local nvm = techage.get_nvm(pos)
nvm.liquid = nvm.liquid or {}
nvm.liquid.amount = nvm.liquid.amount or 0
if payload[1] == 1 then
local value = techage.power.percent(LQD(pos).capa, nvm.liquid.amount)
return 0, {math.floor(value + 0.5)}
else
return 0, {nvm.liquid.amount}
end
else
return 2, ""
end
end,
}
-- like: register_liquid("techage:ta3_barrel_oil", "techage:ta3_barrel_empty", 10, "techage:oil")
@ -83,6 +101,9 @@ function techage.register_liquid(full_container, empty_container, container_size
ContainerDef[empty_container] = ContainerDef[empty_container] or {}
ContainerDef[empty_container][inv_item] = full_container
IsLiquid[inv_item] = true
if inv_item == "techage:water" and container_size == 1 then
techage.register_water_bucket(empty_container, full_container)
end
end
local function get_liquid_def(full_container)

View File

@ -12,6 +12,7 @@
]]--
local MAX_NUM = 128
local marker = {}
local MarkedNodes = {} -- t[player] = {{entity, pos},...}
@ -59,7 +60,7 @@ function marker.get_poslist(name)
for _,item in ipairs(MarkedNodes[name] or {}) do
table.insert(lst, item.pos)
idx = idx + 1
if idx >= 16 then break end
if idx >= MAX_NUM then break end
end
return lst
end
@ -86,6 +87,14 @@ function marker.stop(name)
MaxNumber[name] = nil
end
minetest.register_on_leaveplayer(function(ObjectRef, timed_out)
if ObjectRef and ObjectRef:is_player() then
local name = ObjectRef:get_player_name()
marker.unmark_all(name)
end
end)
minetest.register_entity(":techage:block_marker", {
initial_properties = {
visual = "cube",
@ -97,7 +106,6 @@ minetest.register_entity(":techage:block_marker", {
"techage_cube_mark.png",
"techage_cube_mark.png",
},
--use_texture_alpha = true,
physical = false,
visual_size = {x=1.1, y=1.1},
collisionbox = {-0.55,-0.55,-0.55, 0.55,0.55,0.55},

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -62,16 +62,20 @@ local P = minetest.string_to_pos
local M = minetest.get_meta
local N = techage.get_node_lvm
local MAX_CYCLE_TIME = 20
--
-- TechAge machine states
--
techage.RUNNING = 1 -- in normal operation/turned on
techage.BLOCKED = 2 -- a pushing node is blocked due to a full destination inventory
techage.STANDBY = 3 -- nothing to do (e.g. no input items), or node (world) not loaded
techage.NOPOWER = 4 -- only for power consuming nodes, no operation
techage.FAULT = 5 -- any fault state (e.g. wrong source items), which can be fixed by the player
techage.STOPPED = 6 -- not operational/turned off
techage.RUNNING = 1 -- in normal operation/turned on
techage.BLOCKED = 2 -- a pushing node is blocked due to a full destination inventory
techage.STANDBY = 3 -- nothing to do (e.g. no input items), or node (world) not loaded
techage.NOPOWER = 4 -- only for power consuming nodes, no operation
techage.FAULT = 5 -- any fault state (e.g. wrong source items), which can be fixed by the player
techage.STOPPED = 6 -- not operational/turned off
techage.UNLOADED = 7 -- Map block unloaded
techage.INACTIVE = 8 -- Map block loaded but node is not actively working
techage.StatesImg = {
"techage_inv_button_on.png",
@ -133,13 +137,15 @@ local function has_power(pos, nvm)
return true
end
local function swap_node(pos, name)
local function swap_node(pos, new_name, old_name)
local node = techage.get_node_lvm(pos)
if node.name == name then
if node.name == new_name then
return
end
node.name = name
minetest.swap_node(pos, node)
if node.name == old_name then
node.name = new_name
minetest.swap_node(pos, node)
end
end
-- true if node_timer should be executed
@ -174,7 +180,7 @@ function NodeStates:new(attr)
cycle_time = attr.cycle_time, -- for running state
standby_ticks = attr.standby_ticks, -- for standby state
-- optional
countdown_ticks = attr.countdown_ticks or 1,
countdown_ticks = attr.countdown_ticks or 1,
node_name_passive = attr.node_name_passive,
node_name_active = attr.node_name_active,
infotext_name = attr.infotext_name,
@ -220,7 +226,7 @@ function NodeStates:stop(pos, nvm)
self.stop_node(pos, nvm, state)
end
if self.node_name_passive then
swap_node(pos, self.node_name_passive)
swap_node(pos, self.node_name_passive, self.node_name_active)
end
if self.infotext_name then
local number = M(pos):get_string("node_number")
@ -257,7 +263,7 @@ function NodeStates:start(pos, nvm)
end
nvm.techage_countdown = self.countdown_ticks
if self.node_name_active then
swap_node(pos, self.node_name_active)
swap_node(pos, self.node_name_active, self.node_name_passive)
end
if self.infotext_name then
local number = M(pos):get_string("node_number")
@ -278,6 +284,7 @@ function NodeStates:start(pos, nvm)
if self.quick_start and state == STOPPED then
self.quick_start(pos, 0)
end
self:trigger_state(pos, nvm)
return true
end
return false
@ -288,7 +295,7 @@ function NodeStates:standby(pos, nvm, err_string)
if state == RUNNING or state == BLOCKED then
nvm.techage_state = STANDBY
if self.node_name_passive then
swap_node(pos, self.node_name_passive)
swap_node(pos, self.node_name_passive, self.node_name_active)
end
if self.infotext_name then
local number = M(pos):get_string("node_number")
@ -313,7 +320,7 @@ function NodeStates:blocked(pos, nvm, err_string)
if state == RUNNING then
nvm.techage_state = BLOCKED
if self.node_name_passive then
swap_node(pos, self.node_name_passive)
swap_node(pos, self.node_name_passive, self.node_name_active)
end
if self.infotext_name then
local number = M(pos):get_string("node_number")
@ -337,7 +344,7 @@ function NodeStates:nopower(pos, nvm, err_string)
if state ~= NOPOWER then
nvm.techage_state = NOPOWER
if self.node_name_passive then
swap_node(pos, self.node_name_passive)
swap_node(pos, self.node_name_passive, self.node_name_active)
end
if self.infotext_name then
local number = M(pos):get_string("node_number")
@ -362,7 +369,7 @@ function NodeStates:fault(pos, nvm, err_string)
if state == RUNNING or state == STOPPED then
nvm.techage_state = FAULT
if self.node_name_passive then
swap_node(pos, self.node_name_passive)
swap_node(pos, self.node_name_passive, self.node_name_active)
end
if self.infotext_name then
local number = M(pos):get_string("node_number")
@ -464,7 +471,7 @@ function NodeStates:on_receive_message(pos, topic, payload)
if node.name == "ignore" then -- unloaded node?
return "unloaded"
elseif nvm.techage_state == RUNNING then
local ttl = (nvm.last_active or 0) + 2 * (self.cycle_time or 0)
local ttl = (nvm.last_active or 0) + MAX_CYCLE_TIME
if ttl < minetest.get_gametime() then
return "inactive"
end
@ -479,6 +486,54 @@ function NodeStates:on_receive_message(pos, topic, payload)
end
end
function NodeStates:on_beduino_receive_cmnd(pos, topic, payload)
if topic == 1 then
if payload[1] == 0 then
self:stop(pos, techage.get_nvm(pos))
return 0
else
self:start(pos, techage.get_nvm(pos))
return 0
end
else
return 2 -- unknown or invalid topic
end
end
function NodeStates:on_beduino_request_data(pos, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 128 then
return 0, techage.get_node_lvm(pos).name
elseif topic == 129 then
local node = minetest.get_node(pos)
if node.name == "ignore" then -- unloaded node?
return 0, {techage.UNLOADED}
elseif nvm.techage_state == RUNNING then
local ttl = (nvm.last_active or 0) + MAX_CYCLE_TIME
if ttl < minetest.get_gametime() then
return 0, {techage.INACTIVE}
end
end
return 0, {nvm.techage_state or STOPPED}
else
return 2, "" -- topic is unknown or invalid
end
end
function NodeStates.get_beduino_state(pos)
local node = minetest.get_node(pos)
local nvm = techage.get_nvm(pos)
if node.name == "ignore" then -- unloaded node?
return 0, {techage.UNLOADED}
elseif nvm.techage_state == RUNNING then
local ttl = (nvm.last_active or 0) + MAX_CYCLE_TIME
if ttl < minetest.get_gametime() then
return 0, {techage.INACTIVE}
end
end
return 0, {nvm.techage_state or STOPPED}
end
-- restart timer
function NodeStates:on_node_load(pos)
local nvm = techage.get_nvm(pos)

View File

@ -71,7 +71,7 @@ end
-------------------------------------------------------------------
-- Storage scheduler
-------------------------------------------------------------------
local CYCLE_TIME = 900 -- store data every 15 min
local CYCLE_TIME = 600 -- store data every 10 min
local JobQueue = {}
local first = 0
local last = -1
@ -97,7 +97,9 @@ minetest.register_globalstep(function(dtime)
SystemTime = SystemTime + dtime
local key = pop()
if key and NvmStore[key] then
--debug(key, NvmStore[key])
-- minetest.log("warning",
-- string.format("[TA Storage] SystemTime = %.3f, #JobQueue = %d, in_use = %s",
-- SystemTime, last - first, NvmStore[key].in_use))
local t = minetest.get_us_time()
if NvmStore[key].in_use then
NvmStore[key].in_use = nil
@ -151,6 +153,18 @@ function techage.get_nvm(pos)
return block[key2]
end
-- Returns true/false
function techage.has_nvm(pos)
local key1, key2 = get_keys(pos)
if not NvmStore[key1] then
NvmStore[key1] = backend.get_mapblock_data(key1)
push(key1)
end
return NvmStore[key1][key2] ~= nil
end
function techage.peek_nvm(pos)
local key1, key2 = get_keys(pos)
local block = NvmStore[key1] or {}

View File

@ -65,6 +65,7 @@ function api.store_mapblock_data(key, mapblock_data)
if pos then
item._POS_ = nil
local data = serialize(item)
item._POS_ = pos
local meta = M(pos)
meta:set_string("ta_data", data)
meta:mark_as_private("ta_data")

View File

@ -20,6 +20,7 @@ local M = minetest.get_meta
-------------------------------------------------------------------
local MN = minetest.get_current_modname()
local WP = minetest.get_worldpath()
local use_marshal = minetest.settings:get_bool('techage_use_marshal', false)
local MAR_MAGIC = 0x8e
if not techage.IE then
@ -55,7 +56,6 @@ local function set_block(key, data)
set:bind(1, key)
set:bind_blob(2, data)
set:step()
return true
end
local function get_block(key)
@ -72,10 +72,14 @@ end
local api = {}
function api.store_mapblock_data(key, mapblock_data)
-- deactivated due to weird server crashes without error logs
--local s = marshal.encode(mapblock_data)
local s = minetest.serialize(mapblock_data)
return set_block(key, s)
if use_marshal and mapblock_data then
local data = marshal.encode(mapblock_data)
if data then
set_block(key, data)
end
else
set_block(key, minetest.serialize(mapblock_data))
end
end
function api.get_mapblock_data(key)

88
basis/pack_lib.lua Normal file
View File

@ -0,0 +1,88 @@
--[[
TechAge
=======
Copyright (C) 2019-2024 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
Packing functions
]]--
-- for lazy programmers
local P2S = function(pos) if pos then return minetest.pos_to_string(pos) end end
local M = minetest.get_meta
-- string/usercode conversion
local function usercode_to_string(tbl)
if tbl and tbl.inventory then
for list_name,list in pairs(tbl.inventory) do
for i,item in ipairs(list) do
tbl.inventory[list_name][i] = item:to_string()
end
end
end
end
local function string_to_usercode(tbl)
if tbl and tbl.inventory then
for list_name,list in pairs(tbl.inventory) do
for i,item in ipairs(list) do
tbl.inventory[list_name][i] = ItemStack(item)
end
end
end
end
-- pack/unpack node nvm data
local function pack_nvm(pos)
if techage.has_nvm(pos) then
local s = minetest.serialize(techage.get_nvm(pos))
techage.del_mem(pos)
return s
end
end
local function unpack_nvm(pos, s)
if s and s ~= "" then
local tbl = minetest.deserialize(s)
local nvm = techage.get_nvm(pos)
for k,v in pairs(tbl) do
nvm.k = v
end
end
end
-- pack/unpack node metedata
local function pack_meta(pos)
local tbl = M(pos):to_table() or {}
usercode_to_string(tbl)
return minetest.serialize(tbl)
end
local function unpack_meta(pos, s)
if s and s ~= "" then
local tbl = minetest.deserialize(s) or {}
string_to_usercode(tbl)
M(pos):from_table(tbl)
end
end
-------------------------------------------------------------------------------
-- preserve/restore API functions
-------------------------------------------------------------------------------
function techage.preserve_nodedata(pos)
local smeta = pack_meta(pos)
local snvm = pack_nvm(pos)
return minetest.serialize({smeta = smeta, snvm = snvm})
end
function techage.restore_nodedata(pos, s)
local tbl = minetest.deserialize(s) or {}
unpack_nvm(pos, tbl.snvm)
unpack_meta(pos, tbl.smeta)
end

View File

@ -74,9 +74,12 @@ local function input_string(recipe)
return table.concat(tbl, "")
end
function techage.recipes.get(nvm, rtype)
function techage.recipes.get(nvm, rtype, owner)
local recipes = Recipes[rtype] or {}
return recipes[nvm.recipe_idx or 1]
if owner then
recipes = filter_recipes_based_on_points(recipes, owner)
end
return recipes[nvm.recipe_idx or 1] or recipes[1]
end
-- Add 4 input/output/waste recipe
@ -156,8 +159,10 @@ function techage.recipes.on_receive_fields(pos, formname, fields, player)
if not nvm.running then
if fields.next == ">>" then
nvm.recipe_idx = nvm.recipe_idx + 1
return true
elseif fields.priv == "<<" then
nvm.recipe_idx = nvm.recipe_idx - 1
return true
end
end
end
@ -166,6 +171,14 @@ function techage.recipes.get_recipe(name)
return NormalizedRecipes[name]
end
function techage.recipes.set_recipe(pos, rtype, idx)
local nvm = techage.get_nvm(pos)
if not nvm.running then
local recipes = Recipes[rtype] or {}
idx = tonumber(idx) or 1
nvm.recipe_idx = range(idx, 1, #recipes)
end
end
function techage.recipes.get_default_group_item_name(item_name)
if item_name and item_name:sub(1, 6) == "group:" then

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2022 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -31,7 +31,7 @@ end
function techage.shared_inv.node_timer(pos, elapsed)
local rmt_pos = remote_pos(pos)
if techage.is_activeformspec(pos) then
if rmt_pos and techage.is_activeformspec(pos) then
copy_inventory_list(rmt_pos, pos, "main")
return true
end
@ -42,8 +42,10 @@ end
function techage.shared_inv.before_inv_access(pos, listname)
if hyperloop.is_client(pos) then
local rmt_pos = remote_pos(pos)
copy_inventory_list(rmt_pos, pos, listname)
return true
if rmt_pos then
copy_inventory_list(rmt_pos, pos, listname)
return true
end
end
return false
end
@ -52,8 +54,10 @@ end
function techage.shared_inv.after_inv_access(pos, listname)
if hyperloop.is_client(pos) then
local rmt_pos = remote_pos(pos)
copy_inventory_list(pos, rmt_pos, listname)
return true
if rmt_pos then
copy_inventory_list(pos, rmt_pos, listname)
return true
end
end
return false
end
@ -61,8 +65,10 @@ end
function techage.shared_inv.on_rightclick(pos, clicker, listname)
if hyperloop.is_client(pos) then
local rmt_pos = remote_pos(pos)
copy_inventory_list(rmt_pos, pos, listname)
techage.set_activeformspec(pos, clicker)
minetest.get_node_timer(pos):start(2)
if rmt_pos then
copy_inventory_list(rmt_pos, pos, listname)
techage.set_activeformspec(pos, clicker)
minetest.get_node_timer(pos):start(2)
end
end
end

View File

@ -16,8 +16,8 @@ local S = techage.S
techage.menu = {}
local function index(list, x)
for idx, v in ipairs(list) do
if v == x then return idx end
for idx, v in ipairs(list or {}) do
if tostring(v) == x then return idx end
end
return nil
end
@ -99,9 +99,8 @@ local function generate_formspec_substring(pos, meta, form_def, player_name)
end
tbl[#tbl+1] = "label[4.75," .. offs .. ";" .. val .. "]"
elseif elem.type == "dropdown" then
local l = elem.choices:split(",")
if nvm.running or techage.is_running(nvm) then
local val = elem.default
local val = elem.default or ""
if meta:contains(elem.name) then
val = meta:get_string(elem.name) or ""
end
@ -120,11 +119,21 @@ local function generate_formspec_substring(pos, meta, form_def, player_name)
if meta:contains(elem.name) then
val = meta:get_string(elem.name) or ""
end
local idx = index(l, val) or 1
local idx
if elem.values then
idx = index(elem.values, val) or 1
else
local l = elem.choices:split(",")
idx = index(l, val) or 1
end
tbl[#tbl+1] = "dropdown[4.72," .. (offs) .. ";5.5,1.4;" .. elem.name .. ";" .. elem.choices .. ";" .. idx .. "]"
end
elseif elem.type == "items" then -- inventory
tbl[#tbl+1] = "list[detached:" .. minetest.formspec_escape(player_name) .. "_techage_wrench_menu;cfg;4.75," .. offs .. ";" .. elem.size .. ",1;]"
if elem.size then
tbl[#tbl+1] = "list[detached:" .. minetest.formspec_escape(player_name) .. "_techage_wrench_menu;cfg;4.75," .. offs .. ";" .. elem.size .. ",1;]"
else
tbl[#tbl+1] = "list[detached:" .. minetest.formspec_escape(player_name) .. "_techage_wrench_menu;cfg;4.75," .. offs .. ";" .. elem.width .. "," .. elem.height .. ";]"
end
player_inv_needed = true
end
end
@ -137,9 +146,9 @@ local function generate_formspec_substring(pos, meta, form_def, player_name)
return player_inv_needed, table.concat(tbl, "")
end
local function value_check(elem, value)
local function value_check(elem, value, player_name)
if elem.check then
return elem.check(value)
return elem.check(value, player_name)
end
return value ~= nil
end
@ -159,7 +168,7 @@ local function evaluate_data(pos, meta, form_def, fields, player_name)
meta:set_string(elem.name, "")
elseif fields[elem.name]:find("^[%d ]+$") then
local val = tonumber(fields[elem.name])
if value_check(elem, val) then
if value_check(elem, val, player_name) then
meta:set_int(elem.name, val)
--print("set_int", elem.name, val)
else
@ -173,7 +182,8 @@ local function evaluate_data(pos, meta, form_def, fields, player_name)
if fields[elem.name] then
if fields[elem.name] == "" then
meta:set_string(elem.name, "")
elseif fields[elem.name]:find("^[%d ]+$") and value_check(elem, fields[elem.name]) then
elseif fields[elem.name]:find("^[%d ]+$") and
value_check(elem, fields[elem.name], player_name) then
meta:set_string(elem.name, fields[elem.name])
else
res = false
@ -184,7 +194,7 @@ local function evaluate_data(pos, meta, form_def, fields, player_name)
meta:set_string(elem.name, "")
elseif fields[elem.name] then
local val = tonumber(fields[elem.name])
if val and value_check(elem, val) then
if val and value_check(elem, val, player_name) then
meta:set_string(elem.name, val)
else
res = false
@ -194,7 +204,7 @@ local function evaluate_data(pos, meta, form_def, fields, player_name)
if fields[elem.name] == ""then
meta:set_string(elem.name, "")
elseif fields[elem.name] then
if value_check(elem, fields[elem.name]) then
if value_check(elem, fields[elem.name], player_name) then
meta:set_string(elem.name, fields[elem.name])
else
res = false
@ -202,7 +212,14 @@ local function evaluate_data(pos, meta, form_def, fields, player_name)
end
elseif elem.type == "dropdown" then
if fields[elem.name] ~= nil then
meta:set_string(elem.name, fields[elem.name])
if elem.values then
local l = elem.choices:split(",")
local idx = index(l, fields[elem.name]) or 1
local text = elem.values[idx]
meta:set_string(elem.name, text)
else
meta:set_string(elem.name, fields[elem.name])
end
end
elseif elem.type == "items" and player_name then
local inv_name = minetest.formspec_escape(player_name) .. "_techage_wrench_menu"
@ -294,3 +311,8 @@ function techage.menu.eval_input(pos, form_def, fields, player_name)
end
return fields.refresh or fields.save or fields.key_enter_field
end
function techage.dropdown_index(sChoices, selected_value)
local l = sChoices:split(",")
return index(l, selected_value) or 1
end

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -16,6 +16,12 @@ local S = techage.S
local P = minetest.string_to_pos
local M = minetest.get_meta
local OCEAN = "ocean"
if minetest.global_exists("asuna") then
OCEAN = "below"
end
local function chat_message(player_name, msg)
if player_name then
minetest.chat_send_player(player_name, S("[TA4 Wind Turbine]").." "..msg)
@ -39,7 +45,7 @@ function techage.valid_place_for_windturbine(pos, player_name, num_turbines)
local data = minetest.get_biome_data({x=pos.x, y=-2, z=pos.z})
if data then
local name = minetest.get_biome_name(data.biome)
if not string.find(name, "ocean") then
if not string.find(name, OCEAN) then
return chat_message(player_name, S("This is a").." "..name.." "..S("biome and no ocean!"))
end
end

60
beduino/kv_store.lua Normal file
View File

@ -0,0 +1,60 @@
--[[
TechAge
=======
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
K/V Store for the Beduino controller
]]--
local COSTS = 400
local function ta_kv_init(cpu_pos, address, regA, regB, regC)
local nvm = techage.get_nvm(cpu_pos)
nvm.kv_store = {}
return 1, COSTS
end
local function ta_kv_add(cpu_pos, address, regA, regB, regC)
local nvm = techage.get_nvm(cpu_pos)
local text = vm16.read_ascii(cpu_pos, regA, 32)
nvm.kv_store[text] = regB
return 1, COSTS
end
local function ta_kv_get(cpu_pos, address, regA, regB, regC)
local nvm = techage.get_nvm(cpu_pos)
local text = vm16.read_ascii(cpu_pos, regA, 32)
return nvm.kv_store[text] or 0, COSTS
end
local kvstore_c = [[
// Initialize the key/value store
func ta_kv_init() {
return system(0x140, 0);
}
// Add a key/value pair to the store
func ta_kv_add(key_str, value) {
return system(0x141, key_str, value);
}
// Returns the value for the given key string
func ta_kv_get(key_str) {
return system(0x142, key_str);
}
]]
minetest.register_on_mods_loaded(function()
if minetest.global_exists("beduino") and minetest.global_exists("vm16") then
beduino.lib.register_SystemHandler(0x140, ta_kv_init)
beduino.lib.register_SystemHandler(0x141, ta_kv_add)
beduino.lib.register_SystemHandler(0x142, ta_kv_get)
vm16.register_ro_file("beduino", "lib/ta_kvstore.c", kvstore_c)
end
end)

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -159,6 +159,15 @@ techage.register_node({"techage:chest_cart"}, {
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 131 then -- Chest State
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return 0, {techage.get_inv_state_num(inv, "main")}
else
return 2, ""
end
end,
})
Tube:set_valid_sides("techage:chest_cart", {"L", "R", "F", "B"})

View File

@ -21,7 +21,7 @@ local Pipe = techage.LiquidPipe
local MP = minetest.get_modpath("minecart")
local liquid = networks.liquid
local CAPACITY = 100
local CAPACITY = 200
local function on_rightclick(pos, node, clicker)
if clicker and clicker:is_player() then

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -272,7 +272,11 @@ local function on_receive_fields(pos, formname, fields, player)
local nvm = techage.get_nvm(pos)
if not nvm.running then
recipes.on_receive_fields(pos, formname, fields, player)
if recipes.on_receive_fields(pos, formname, fields, player) then
local mem = techage.get_mem(pos)
mem.waste_leftover = nil
mem.output_leftover = nil
end
end
local mem = techage.get_mem(pos)
mem.dbg_cycles = 5
@ -327,7 +331,7 @@ minetest.register_node("techage:ta4_doser_on", {
"techage_filling_ta4.png^techage_frame_ta4_top.png^techage_appl_hole_pipe.png",
"techage_filling_ta4.png^techage_frame_ta4.png",
{
image = "techage_filling8_ta4.png^techage_frame8_ta4.png^techage_appl_pump_up8.png",
name = "techage_filling8_ta4.png^techage_frame8_ta4.png^techage_appl_pump_up8.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -358,7 +362,18 @@ liquid.register_nodes({"techage:ta4_doser", "techage:ta4_doser_on"}, Pipe, "pump
techage.register_node({"techage:ta4_doser", "techage:ta4_doser_on"}, {
on_recv_message = function(pos, src, topic, payload)
return State:on_receive_message(pos, topic, payload)
if topic == "recipe" then
techage.recipes.set_recipe(pos, "ta4_doser", payload)
return true
else
return State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return State:on_beduino_request_data(pos, topic, payload)
end,
})

View File

@ -168,6 +168,28 @@ minetest.register_node("techage:ta4_reactor", {
sounds = default.node_sound_metal_defaults(),
})
techage.register_node({"techage:ta4_reactor"}, {
on_inv_request = function(pos, in_dir, access_type)
local meta = minetest.get_meta(pos)
return meta:get_inventory(), "main"
end,
on_pull_item = function(pos, in_dir, num, item_name)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.get_items(pos, inv, "main", num)
end,
on_push_item = function(pos, in_dir, stack)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.put_items(inv, "main", stack)
end,
on_unpull_item = function(pos, in_dir, stack)
local meta = minetest.get_meta(pos)
local inv = meta:get_inventory()
return techage.put_items(inv, "main", stack)
end,
})
minetest.register_craft({
output = 'techage:ta4_reactor',
recipe = {

View File

@ -37,7 +37,7 @@ minetest.register_node("techage:cooler", {
tiles = {
-- up, down, right, left, back, front
{
image = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -47,7 +47,7 @@ minetest.register_node("techage:cooler", {
},
},
{
image = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -78,7 +78,7 @@ minetest.register_node("techage:cooler_on", {
tiles = {
-- up, down, right, left, back, front
{
image = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -88,7 +88,7 @@ minetest.register_node("techage:cooler_on", {
},
},
{
image = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_cooler4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -86,7 +86,7 @@ minetest.register_node("techage:coalfirebox", {
after_place_node = function(pos, placer)
if firebox.is_free_position(pos, placer:get_player_name()) then
techage.add_node(pos, "techage:coalfirebox")
techage.add_node(pos, "techage:coalfirebox", true)
local nvm = techage.get_nvm(pos)
nvm.running = false
nvm.burn_cycles = 0
@ -149,7 +149,7 @@ minetest.register_node("techage:coalfirehole_on", {
"techage_coal_boiler.png^[colorize:black:80",
"techage_coal_boiler.png^[colorize:black:80",
{
image = "techage_coal_boiler4.png^[colorize:black:80^techage_appl_firehole4.png",
name = "techage_coal_boiler4.png^[colorize:black:80^techage_appl_firehole4.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -207,6 +207,18 @@ techage.register_node({"techage:coalfirebox"}, {
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 128 then
return 0, techage.get_node_lvm(pos).name
elseif topic == 129 then
return 0, {nvm.running and techage.RUNNING or techage.STOPPED}
elseif topic == 132 then
return 0, {techage.fuel.get_fuel_amount(nvm)}
else
return 2, ""
end
end,
})
minetest.register_craft({

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -170,7 +170,7 @@ minetest.register_node("techage:generator_on", {
"techage_filling_ta3.png^techage_appl_hole_electric.png^techage_frame_ta3.png",
"techage_filling_ta3.png^techage_appl_open.png^techage_frame_ta3.png",
{
image = "techage_filling4_ta3.png^techage_appl_generator4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_generator4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -180,7 +180,7 @@ minetest.register_node("techage:generator_on", {
},
},
{
image = "techage_filling4_ta3.png^techage_appl_generator4.png^[transformFX]^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_generator4.png^[transformFX]^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -231,6 +231,17 @@ techage.register_node({"techage:generator", "techage:generator_on"}, {
return State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 135 then -- Delivered Power
return 0, {math.floor((nvm.provided or 0) + 0.5)}
else
return State:on_beduino_request_data(pos, topic, payload)
end
end,
})
-- used by power terminal

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -88,7 +88,7 @@ minetest.register_node("techage:oilfirebox", {
after_place_node = function(pos, placer)
if firebox.is_free_position(pos, placer:get_player_name()) then
techage.add_node(pos, "techage:oilfirebox")
techage.add_node(pos, "techage:oilfirebox", true)
local nvm = techage.get_nvm(pos)
nvm.running = false
nvm.burn_cycles = 0
@ -132,6 +132,18 @@ techage.register_node({"techage:oilfirebox"}, {
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 128 then
return 0, techage.get_node_lvm(pos).name
elseif topic == 129 then
return 0, {nvm.running and techage.RUNNING or techage.STOPPED}
elseif topic == 132 then
return 0, {fuel.get_fuel_amount(nvm)}
else
return 2, ""
end
end,
})
minetest.register_craft({

View File

@ -82,7 +82,7 @@ minetest.register_node("techage:turbine", {
"techage_filling_ta3.png^techage_frame_ta3.png",
"techage_filling_ta3.png^techage_appl_open.png^techage_frame_ta3.png",
"techage_filling_ta3.png^techage_frame_ta3.png^techage_steam_hole.png",
"techage_filling_ta3.png^techage_appl_turbine.png^techage_frame_ta3.png",
"techage_filling_ta3.png^techage_appl_turbine.png^techage_frame_ta3.png^[transformFX",
"techage_filling_ta3.png^techage_appl_turbine.png^techage_frame_ta3.png",
},
@ -105,7 +105,7 @@ minetest.register_node("techage:turbine_on", {
"techage_filling_ta3.png^techage_appl_open.png^techage_frame_ta3.png",
"techage_filling_ta3.png^techage_frame_ta3.png^techage_steam_hole.png",
{
image = "techage_filling4_ta3.png^techage_appl_turbine4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_turbine4.png^techage_frame4_ta3.png^[transformFX",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -115,7 +115,7 @@ minetest.register_node("techage:turbine_on", {
},
},
{
image = "techage_filling4_ta3.png^techage_appl_turbine4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_turbine4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",

View File

@ -23,7 +23,7 @@ minetest.register_node("techage:ta4_collider_cooler", {
tiles = {
-- up, down, right, left, back, front
{
image = "techage_appl_cooler4.png^techage_frame4_ta4_top.png",
name = "techage_appl_cooler4.png^techage_frame4_ta4_top.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -33,7 +33,7 @@ minetest.register_node("techage:ta4_collider_cooler", {
},
},
{
image = "techage_appl_cooler4.png^techage_frame4_ta4_top.png",
name = "techage_appl_cooler4.png^techage_frame4_ta4_top.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -47,7 +47,6 @@ minetest.register_node("techage:ta4_collider_cooler", {
"techage_filling_ta4.png^techage_frame_ta4.png^techage_cooler.png",
"techage_filling_ta4.png^techage_frame_ta4.png^techage_cooler.png",
},
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {cracky = 1},
on_rotate = screwdriver.disallow,

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -21,7 +21,9 @@ local getpos = techage.assemble.get_pos
local CYCLE_TIME = 2
local TNO_MAGNETS = 22
local PROBABILITY = 180 -- check every 20 s => 20 * 180 * 50% = 30 min
local IMPROBABILITY = 40 -- every 40 min
-- one point per 40 min: check every 20 s => factor = 40 * 3 = 120
IMPROBABILITY = (minetest.settings:get("techage_expoint_rate_in_min") or 40) * 3
local TIME_SLOTS = 10
local Schedule = {[0] =
@ -59,7 +61,7 @@ local function terminal_message(pos, msg)
end
local function experience_points(pos)
if math.random(PROBABILITY) == 1 then
if math.random(IMPROBABILITY) == 1 then
local owner = M(pos):get_string("owner")
local own_num = M(pos):get_string("node_number")
local player = minetest.get_player_by_name(owner)
@ -155,7 +157,7 @@ local function create_task(pos, task)
end
-- Call on_cyclic_check of all magents so that the magnets don't need a FLB.
local function magnet_on_cyclic_check(pos, nvm)
local function magnets_on_cyclic_check(pos, nvm)
local ndef = minetest.registered_nodes["techage:ta4_magnet"]
for idx,pos2 in ipairs(nvm.magnet_positions or {}) do
local res = ndef.on_cyclic_check(pos2)
@ -171,6 +173,29 @@ local function magnet_on_cyclic_check(pos, nvm)
return true
end
-- Turn off all magnets so that they don't consume power
local function magnets_turn_off(pos, nvm)
local ndef = minetest.registered_nodes["techage:ta4_magnet"]
for idx,pos2 in ipairs(nvm.magnet_positions or {}) do
ndef.on_turn_off(pos2)
end
end
local function cable_inlets_turn_on_off(pos, on)
local turn_on_off = function(pos, param2, item)
local pos2 = getpos(pos, param2, item.route, item.yoffs)
local node2 = minetest.get_node(pos2)
if item.name == node2.name then
local nvm = techage.get_nvm(pos2)
techage.power_inlet_turn_on_off(pos2, nvm, on)
end
end
local param2 = minetest.get_node(pos).param2
turn_on_off(pos, param2, Schedule[2])
turn_on_off(pos, param2, Schedule[3])
end
minetest.register_node("techage:ta4_detector_core", {
description = S("TA4 Collider Detector Core"),
tiles = {
@ -182,7 +207,6 @@ minetest.register_node("techage:ta4_detector_core", {
"default_steel_block.png^techage_collider_detector_core.png",
"default_steel_block.png^techage_collider_detector_core.png",
},
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {cracky = 1},
is_ground_content = false,
@ -200,29 +224,33 @@ minetest.register_node("techage:ta4_detector_core", {
on_timer = function(pos, elapsed)
local nvm = techage.get_nvm(pos)
if not magnet_on_cyclic_check(pos, nvm) then
techage.del_laser(pos)
if nvm.running then
terminal_message(pos, "Detector stopped.")
nvm.running = false
end
nvm.magnet_positions = nil
elseif nvm.running then
local res = check_state(pos)
if res == true then
experience_points(pos)
add_laser(pos)
if nvm.ticks <= TIME_SLOTS then -- only once
terminal_message(pos, "Detector running.")
end
elseif res == false then
if nvm.running then
if not magnets_on_cyclic_check(pos, nvm) then
techage.del_laser(pos)
terminal_message(pos, "Detector stopped.")
magnets_turn_off(pos, nvm)
cable_inlets_turn_on_off(pos, false)
nvm.running = false
nvm.magnet_positions = nil
terminal_message(pos, "Detector stopped.")
end
if nvm.running then
play_sound(pos)
else
local res = check_state(pos)
if res == true then
experience_points(pos)
add_laser(pos)
if nvm.ticks <= TIME_SLOTS then -- only once
terminal_message(pos, "Detector running.")
end
elseif res == false then
techage.del_laser(pos)
magnets_turn_off(pos, nvm)
cable_inlets_turn_on_off(pos, false)
nvm.running = false
nvm.magnet_positions = nil
terminal_message(pos, "Detector stopped.")
end
if nvm.running then
play_sound(pos)
end
end
end
return true
@ -285,6 +313,7 @@ local function start_task(pos)
end
nvm.magnet_positions = t
techage.send_single(own_num, term_num, "append", "ok")
cable_inlets_turn_on_off(pos, true)
coroutine.yield()
techage.send_single(own_num, term_num, "text", "- Check magnets...")
@ -308,6 +337,7 @@ local function start_task(pos)
techage.send_single(own_num, term_num, "append", err .. "!!!")
nvm.magnet_positions = nil
nvm.locked = false
cable_inlets_turn_on_off(pos, false)
return
end
else
@ -321,12 +351,14 @@ local function start_task(pos)
techage.send_single(own_num, term_num, "append", err .. "!!!")
nvm.magnet_positions = nil
nvm.locked = false
cable_inlets_turn_on_off(pos, false)
return
end
else
techage.send_single(own_num, term_num, "append", "defect!!!")
nvm.magnet_positions = nil
nvm.locked = false
cable_inlets_turn_on_off(pos, false)
return
end
coroutine.yield()
@ -335,7 +367,7 @@ local function start_task(pos)
techage.send_single(own_num, term_num, "append", "ok")
coroutine.yield()
techage.send_single(own_num, term_num, "text", "Collider started.")
techage.send_single(own_num, term_num, "text", "Collider starting...")
nvm.ticks = 0
nvm.running = true
end
@ -370,6 +402,9 @@ techage.register_node({"techage:ta4_detector_core"}, {
nvm.running = false
techage.del_laser(pos)
nvm.locked = false
magnets_turn_off(pos, nvm)
cable_inlets_turn_on_off(pos, false)
nvm.magnet_positions = nil
return "Detector stopped."
elseif topic == "status" then
if nvm.running == true then

View File

@ -56,6 +56,8 @@ minetest.register_node("techage:ta4_collider_tube_inlet", {
fixed = {-4/8, -4/8, -4/8, 4/8, 4/8, 4/8},
},
paramtype2 = "facedir",
paramtype = "light",
use_texture_alpha = techage.CLIP,
groups = {cracky = 1},
on_rotate = screwdriver.disallow,
is_ground_content = false,
@ -328,7 +330,11 @@ minetest.register_node("techage:ta4_collider_cable_inlet", {
on_timer = function(pos, elapsed)
local nvm = techage.get_nvm(pos)
nvm.consumed = power.consume_power(pos, Cable, nil, PWR_NEEDED)
if nvm.running then
nvm.consumed = power.consume_power(pos, Cable, nil, PWR_NEEDED)
else
nvm.consumed = 0
end
return true
end,
@ -346,6 +352,11 @@ function techage.power_inlet_check(pos, node, meta, nvm)
return false, "no power"
end
-- Used by the detector to turn on/off the node
function techage.power_inlet_turn_on_off(pos, nvm, on)
nvm.running = on
end
power.register_nodes({"techage:ta4_collider_cable_inlet"}, Cable, "con", {"F"})
techage.register_node({"techage:ta4_collider_cable_inlet"}, {

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -28,6 +28,23 @@ local VTube = techage.VTube
local power = networks.power
local liquid = networks.liquid
local function is_junction(pos, side)
local node = techage.get_node_lvm(techage.get_pos(pos, side))
return node and techage.string_compare(node.name, "techage:ta3_junction")
end
-- Turn the magnet to the right direction
local function handle_legacy_magnet(pos)
if M(pos):get_string("version") ~= "V2" then
if is_junction(pos, "B") and not is_junction(pos, "F") then
local node = techage.get_node_lvm(pos)
node.param2 = (node.param2 + 2) % 4
minetest.swap_node(pos, node)
end
end
M(pos):set_string("version", "V2")
end
minetest.register_node("techage:ta4_colliderblock", {
description = S("TA4 Collider Steel Block"),
tiles = {
@ -50,7 +67,6 @@ minetest.register_node("techage:ta4_detector_magnet", {
"techage_collider_magnet.png^techage_collider_magnet_appl.png",
"techage_collider_magnet.png^techage_collider_magnet_appl.png",
},
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {cracky = 1},
is_ground_content = false,
@ -61,7 +77,7 @@ minetest.register_node("techage:ta4_magnet", {
description = S("TA4 Collider Magnet"),
inventory_image = minetest.inventorycube(
"techage_collider_magnet.png^techage_appl_hole_electric.png",
"techage_collider_magnet.png^techage_appl_hole_pipe.png",
"techage_collider_magnet.png^techage_collider_magnet_appl.png^techage_appl_hole_pipe.png^techage_collider_magnet_sign.png",
"techage_collider_magnet.png^techage_collider_magnet_tube.png"),
tiles = {
-- up, down, right, left, back, front
@ -69,7 +85,7 @@ minetest.register_node("techage:ta4_magnet", {
"techage_collider_magnet.png",
"techage_collider_magnet.png^techage_collider_magnet_tube.png",
"techage_collider_magnet.png^techage_collider_magnet_tube.png",
"techage_collider_magnet.png^techage_collider_magnet_appl.png^techage_appl_hole_pipe.png^techage_collider_magnet_sign.png",
"techage_collider_magnet.png^techage_collider_magnet_appl.png^techage_collider_magnet_sign.png",
"techage_collider_magnet.png^techage_collider_magnet_appl.png^techage_appl_hole_pipe.png^techage_collider_magnet_sign.png",
},
drawtype = "nodebox",
@ -93,6 +109,8 @@ minetest.register_node("techage:ta4_magnet", {
},
wield_scale = {x = 0.8, y = 0.8, z = 0.8},
paramtype2 = "facedir",
paramtype = "light",
use_texture_alpha = techage.CLIP,
groups = {cracky = 1},
on_rotate = screwdriver.disallow,
is_ground_content = false,
@ -110,6 +128,7 @@ minetest.register_node("techage:ta4_magnet", {
Cable:after_place_node(pos)
VTube:after_place_node(pos)
M(pos):set_string("infotext", S("TA4 Collider Magnet") .. " #0")
M(pos):set_string("version", "V2")
end,
-- To be called by the detector
@ -119,15 +138,23 @@ minetest.register_node("techage:ta4_magnet", {
nvm.consumed = power.consume_power(pos, Cable, 6, PWR_NEEDED)
if nvm.tube_damage then
nvm.tube_damage = nil
nvm.running = nil
return -1
elseif nvm.liquid.amount == CAPACITY and
nvm.liquid.name == "techage:isobutane" and
nvm.consumed == PWR_NEEDED then
nvm.running = true
return 0
end
nvm.running = nil
return -2
end,
on_turn_off = function(pos)
local nvm = techage.get_nvm(pos)
nvm.running = nil
end,
tubelib2_on_update2 = function(pos, outdir, tlib2, node)
if tlib2.tube_type == "vtube" then
local nvm = techage.get_nvm(pos)
@ -148,7 +175,7 @@ minetest.register_node("techage:ta4_magnet", {
})
power.register_nodes({"techage:ta4_magnet"}, Cable, "con", {"U"})
liquid.register_nodes({"techage:ta4_magnet"}, Pipe, "tank", {"F", "B"}, {
liquid.register_nodes({"techage:ta4_magnet"}, Pipe, "tank", {"F"}, {
capa = CAPACITY,
peek = function(pos, indir)
local nvm = techage.get_nvm(pos)
@ -202,6 +229,7 @@ techage.register_node({"techage:ta4_magnet"}, {
return pos2
end
elseif topic == "enumerate" and payload then
handle_legacy_magnet(pos)
payload = tonumber(payload) or 1
nvm.number = payload
M(pos):set_string("infotext", S("TA4 Collider Magnet") .. " #" .. payload)

View File

@ -1,208 +0,0 @@
--[[
Techage
=======
Copyright (C) 2020-2021 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
TA4 Terminal
]]--
local M = minetest.get_meta
local S = techage.S
local STR_LEN = 80
local HELP = [[#### TA4 Terminal ####
Send commands to the connected machine
and output text messages from the
machine.
Commands can have up to 80 characters.
Local commands:
- clear = clear screen
- help = this message
- pub = switch to public use
- priv = switch to private use
- connect <num> = connect the machine
All other commands are machine dependent.
]]
local function get_string(meta, num, default)
local s = meta:get_string("bttn_text"..num)
if not s or s == "" then
return default
end
return s
end
local function formspec2(mem)
mem.command = mem.command or ""
mem.output = mem.output or ""
local output = minetest.formspec_escape(mem.output)
output = output:gsub("\n", ",")
local command = minetest.formspec_escape(mem.command)
local bttn_text1 = get_string(meta, 1, "User1")
local bttn_text2 = get_string(meta, 2, "User2")
local bttn_text3 = get_string(meta, 3, "User3")
local bttn_text4 = get_string(meta, 4, "User4")
local bttn_text5 = get_string(meta, 5, "User5")
local bttn_text6 = get_string(meta, 6, "User6")
local bttn_text7 = get_string(meta, 7, "User7")
local bttn_text8 = get_string(meta, 8, "User8")
local bttn_text9 = get_string(meta, 9, "User9")
return "size[10,8]"..
"style_type[table,field;font=mono]"..
"button[0,0;3.3,1;bttn1;"..bttn_text1.."]button[3.3,0;3.3,1;bttn2;"..bttn_text2.."]button[6.6,0;3.3,1;bttn3;"..bttn_text3.."]"..
"button[0,0.8;3.3,1;bttn4;"..bttn_text4.."]button[3.3,0.8;3.3,1;bttn5;"..bttn_text5.."]button[6.6,0.8;3.3,1;bttn6;"..bttn_text6.."]"..
"button[0,1.6;3.3,1;bttn7;"..bttn_text7.."]button[3.3,1.6;3.3,1;bttn8;"..bttn_text8.."]button[6.6,1.6;3.3,1;bttn9;"..bttn_text9.."]"..
"table[0,2.5;9.8,4.7;output;"..output..";200]"..
"field[0.4,7.7;7.6,1;cmnd;;"..mem.command.."]" ..
"field_close_on_enter[cmnd;false]"..
"button[7.9,7.4;2,1;enter;"..S("Enter").."]"
end
local function output(pos, text)
local mem = techage.get_mem(pos)
mem.output = mem.output .. "\n" .. (text or "")
mem.output = mem.output:sub(-500,-1)
M(pos):set_string("formspec", formspec2(mem))
end
local function command(pos, mem, player)
local meta = minetest.get_meta(pos)
local owner = meta:get_string("owner")
if mem.command == "clear" then
mem.output = ""
mem.command = ""
meta:set_string("formspec", formspec2(mem))
elseif mem.command == "" then
output(pos, ">")
mem.command = ""
meta:set_string("formspec", formspec2(mem))
elseif mem.command == "help" then
local meta = minetest.get_meta(pos)
mem.output = HELP
mem.command = ""
meta:set_string("formspec", formspec2(mem))
elseif mem.command == "pub" and owner == player then
meta:set_int("public", 1)
output(pos, "> "..mem.command)
mem.command = ""
output(pos, "Switched to public use!")
elseif mem.command == "priv" and owner == player then
meta:set_int("public", 0)
output(pos, "> "..mem.command)
mem.command = ""
output(pos, "Switched to private use!")
elseif meta:get_int("public") == 1 or owner == player then
if mem.command == "clear" then
mem.output =
mem.command = ""
meta:set_string("formspec", formspec2(mem))
end
end
end
minetest.register_node("techage:ta4_terminal", {
description = "TA4 Collider Terminal",
tiles = {
-- up, down, right, left, back, front
'techage_terminal1_top.png',
'techage_terminal1_bottom.png',
'techage_terminal1_side.png',
'techage_terminal1_side.png',
'techage_terminal1_bottom.png',
"techage_terminal1_front.png",
},
drawtype = "nodebox",
node_box = {
type = "fixed",
fixed = {
{-12/32, -16/32, -8/32, 12/32, -14/32, 12/32},
{-12/32, -14/32, 12/32, 12/32, 6/32, 14/32},
},
},
selection_box = {
type = "fixed",
fixed = {
{-12/32, -16/32, -8/32, 12/32, -14/32, 12/32},
{-12/32, -14/32, 12/32, 12/32, 6/32, 14/32},
},
},
after_place_node = function(pos, placer)
local number = techage.add_node(pos, minetest.get_node(pos).name)
local meta = minetest.get_meta(pos)
meta:set_string("formspec", formspec1())
meta:set_string("owner", placer:get_player_name())
meta:set_string("infotext", S("TA4 Collider Terminal") .. ": " .. S("not connected")
end,
on_receive_fields = function(pos, formname, fields, player)
local meta = minetest.get_meta(pos)
local mem = techage.get_mem(pos)
if fields.number and fields.number ~= "" then
local owner = meta:get_string("owner")
if techage.check_numbers(fields.number, owner) then
local own_number = meta:get_string("own_number")
if techage.send_single(own_number, fields.number, "connect") == true then
meta:set_string("number", fields.number)
meta:set_string("infotext", S("TA4 Collider Terminal") .. ": " .. S("connected with") .. " " .. fields.number)
meta:set_string("formspec", formspec2(mem))
end
end
elseif (fields.enter or fields.key_enter_field) and fields.cmnd then
mem.command = string.sub(fields.cmnd, 1, STR_LEN)
command(pos, mem, player:get_player_name())
elseif fields.key_up then
mem.command = pdp13.historybuffer_priv(pos)
meta:set_string("formspec", formspec2(mem))
elseif fields.key_down then
mem.command = pdp13.historybuffer_next(pos)
meta:set_string("formspec", formspec2(mem))
end
end,
after_dig_node = function(pos, oldnode, oldmetadata)
techage.remove_node(pos, oldnode, oldmetadata)
end,
paramtype = "light",
use_texture_alpha = techage.CLIP,
sunlight_propagates = true,
paramtype2 = "facedir",
groups = {choppy=2, cracky=2, crumbly=2},
is_ground_content = false,
sounds = default.node_sound_metal_defaults(),
})
minetest.register_craft({
output = "techage:ta4_terminal",
recipe = {
{"", "techage:ta4_display", ""},
{"dye:black", "techage:ta4_wlanchip", "default:copper_ingot"},
{"", "techage:aluminum", ""},
},
})
techage.register_node({"techage:ta4_terminal"}, {
on_recv_message = function(pos, src, topic, payload)
if topic == "term" then
output(pos, payload)
return true
elseif topic == "clear" then
local mem = techage.get_mem(pos)
mem.output = ""
mem.command = ""
M(pos):set_string("formspec", formspec2(mem))
return true
end
end,
})

View File

@ -139,7 +139,6 @@ minetest.register_node("techage:ta4_collider_detector_worker", {
"default_steel_block.png^techage_collider_detector_banner.png",
"default_steel_block.png^techage_collider_detector_appl.png^techage_collider_detector_banner.png",
},
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {cracky = 1},
on_rotate = screwdriver.disallow,

View File

@ -30,7 +30,7 @@ local TOTAL_MAX = INV_SIZE * FUEL_STACK_MAX
local function count_coal(metadata)
local total = 0
for _,stack in pairs(metadata.inventory.fuel) do
for _,stack in pairs(metadata.inventory.fuel or {}) do
total = total + stack:get_count()
end
return total

View File

@ -3,123 +3,59 @@
]]--
local S = techage.S
local M = minetest.get_meta
local MP = minetest.get_modpath("techage")
local tItems = techage.Items -- k/v table with item definitions
local tPlans = techage.ConstructionPlans -- k/v table with plan definitions
local settings = {
symbol_item = "techage:construction_board",
}
doclib.create_manual("techage", "DE", settings)
doclib.create_manual("techage", "EN", settings)
doclib.create_manual("techage", "pt-BR", settings)
local function tooltip(item)
if type(item) == "table" then
local img, name = item[1], item[2]
if img == "" then -- larger image for the plan?
return "", name
elseif img == "10x10" then -- huge image for the plan?
return "10x10", name
elseif img == "5x4" then -- huge image for the plan?
return "5x4", name
end
local ndef = minetest.registered_nodes[name]
if ndef and ndef.description then
return img, minetest.formspec_escape(ndef.description)
end
return img
end
return item
end
local content
content = dofile(MP.."/doc/manual_DE.lua")
doclib.add_to_manual("techage", "DE", content)
content = dofile(MP.."/doc/manual_ta1_DE.lua")
doclib.add_to_manual("techage", "DE", content)
content = dofile(MP.."/doc/manual_ta2_DE.lua")
doclib.add_to_manual("techage", "DE", content)
content = dofile(MP.."/doc/manual_ta3_DE.lua")
doclib.add_to_manual("techage", "DE", content)
content = dofile(MP.."/doc/manual_ta4_DE.lua")
doclib.add_to_manual("techage", "DE", content)
content = dofile(MP.."/doc/manual_ta5_DE.lua")
doclib.add_to_manual("techage", "DE", content)
content = dofile(MP.."/doc/manual_EN.lua")
doclib.add_to_manual("techage", "EN", content)
content = dofile(MP.."/doc/manual_ta1_EN.lua")
doclib.add_to_manual("techage", "EN", content)
content = dofile(MP.."/doc/manual_ta2_EN.lua")
doclib.add_to_manual("techage", "EN", content)
content = dofile(MP.."/doc/manual_ta3_EN.lua")
doclib.add_to_manual("techage", "EN", content)
content = dofile(MP.."/doc/manual_ta4_EN.lua")
doclib.add_to_manual("techage", "EN", content)
content = dofile(MP.."/doc/manual_ta5_EN.lua")
doclib.add_to_manual("techage", "EN", content)
-- formspec images
local function plan(images)
local tbl = {}
if images == "none" then return "label[1,3;"..S("No plan available") .."]" end
for y=1,#images do
for x=1,#images[1] do
local item = images[y][x] or false
if item ~= false then
local img, tooltip = tooltip(item)
local x_offs, y_offs = (x-1) * 0.9, (y-1) * 0.9 + 0.8
if img == "top_view" then
tbl[#tbl+1] = "label["..x_offs..","..y_offs..";"..S("Top view").."]"
elseif img == "side_view" then
tbl[#tbl+1] = "label["..x_offs..","..y_offs..";"..S("Side view").."]"
elseif img == "sectional_view" then
tbl[#tbl+1] = "label["..x_offs..","..y_offs..";"..S("Sectional view").."]"
elseif img == "" then
img = tooltip -- use tooltip for bigger image
tbl[#tbl+1] = "image["..x_offs..","..y_offs..";2.2,2.2;"..img.."]"
elseif img == "10x10" then
img = tooltip -- use tooltip for bigger image
tbl[#tbl+1] = "image["..x_offs..","..y_offs..";10,10;"..img.."]"
elseif img == "5x4" then
img = tooltip -- use tooltip for bigger image
tbl[#tbl+1] = "image["..x_offs..","..y_offs..";5,4;"..img.."]"
elseif string.find(img, ":") then
tbl[#tbl+1] = "item_image["..x_offs..","..y_offs..";1,1;"..img.."]"
else
tbl[#tbl+1] = "image["..x_offs..","..y_offs..";1,1;"..img.."]"
end
if tooltip then
tbl[#tbl+1] = "tooltip["..x_offs..","..y_offs..";1,1;"..tooltip..";#0C3D32;#FFFFFF]"
end
end
end
end
return table.concat(tbl)
end
local function formspec_help(meta, manual)
local bttn
local idx = meta:get_int("index")
local box = "box[9.5,0.9;1,1.1;#BBBBBB]"
local aTitel = manual.aTitel
local aText = manual.aText
local aItemName = manual.aItemName -- item identifier as key
local aPlanTable = manual.aPlanTable -- plan identifier as key
if aPlanTable[idx] ~= "" then
bttn = "button[9.6,1;1,1;plan;"..S("Plan").."]"
elseif aItemName[idx] ~= "" then
local item = tItems[aItemName[idx]] or ""
if string.find(item, ":") then
bttn = box.."item_image[9.6,1;1,1;"..item.."]"
else
bttn = "image[9.3,1;2,2;"..item.."]"
end
else
bttn = box
end
return "size[11,10]"..
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
"item_image[9.6,0;1,1;techage:construction_board]"..
"tablecolumns[tree,width=1;text,width=10,align=inline]"..
"tableoptions[opendepth=1]"..
"table[0.1,0;9,5;page;"..table.concat(aTitel, ",")..";"..idx.."]"..
bttn..
"style_type[textarea;textcolor=#FFFFFF]"..
"textarea[0.3,5.7;11,5.3;;"..(aText[idx] or "")..";]"..
"box[0,5.75;10.775,4.45;#000000]"
end
local function formspec_plan(meta, manual)
local idx = meta:get_int("index")
local images = tPlans[manual.aPlanTable[idx]] or "none"
local titel = string.sub(manual.aTitel[idx], 3) or "unknown"
return "size[11,10]"..
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
"label[0,0;"..titel..":]"..
"button[10,0;1,0.8;back;<<]"..
plan(images)
end
content = dofile(MP.."/doc/manual_pt-BR.lua")
doclib.add_to_manual("techage", "pt-BR", content)
content = dofile(MP.."/doc/manual_ta1_pt-BR.lua")
doclib.add_to_manual("techage", "pt-BR", content)
content = dofile(MP.."/doc/manual_ta2_pt-BR.lua")
doclib.add_to_manual("techage", "pt-BR", content)
content = dofile(MP.."/doc/manual_ta3_pt-BR.lua")
doclib.add_to_manual("techage", "pt-BR", content)
content = dofile(MP.."/doc/manual_ta4_pt-BR.lua")
doclib.add_to_manual("techage", "pt-BR", content)
content = dofile(MP.."/doc/manual_ta5_pt-BR.lua")
doclib.add_to_manual("techage", "pt-BR", content)
local board_box = {
type = "wallmounted",
--wall_top = {-8/16, 15/32, -6/16, 8/16, 8/16, 6/16},
--wall_bottom = {-8/16, 15/32, -6/16, 8/16, 8/16, 6/16},
wall_side = {-16/32, -11/32, -16/32, -15/32, 6/16, 8/16},
}
@ -132,9 +68,8 @@ minetest.register_node("techage:construction_board", {
selection_box = board_box,
after_place_node = function(pos, placer, itemstack)
local meta = minetest.get_meta(pos)
meta:set_int("index", 1)
meta:set_string("formspec", formspec_help(meta, techage.manual_DE))
M(pos):set_string("infotext", "TA Konstruktionsplan (DE)")
M(pos):set_string("formspec", doclib.formspec(pos, "techage", "DE"))
end,
on_receive_fields = function(pos, formname, fields, player)
@ -142,19 +77,7 @@ minetest.register_node("techage:construction_board", {
if minetest.is_protected(pos, player_name) then
return
end
local meta = minetest.get_meta(pos)
if fields.plan then
meta:set_string("formspec", formspec_plan(meta, techage.manual_DE))
elseif fields.back then
meta:set_string("formspec", formspec_help(meta, techage.manual_DE))
elseif fields.page then
local evt = minetest.explode_table_event(fields.page)
if evt.type == "CHG" then
local idx = tonumber(evt.row)
meta:set_int("index", idx)
meta:set_string("formspec", formspec_help(meta, techage.manual_DE))
end
end
M(pos):set_string("formspec", doclib.formspec(pos, "techage", "DE", fields))
end,
paramtype2 = "wallmounted",
@ -184,9 +107,8 @@ minetest.register_node("techage:construction_board_EN", {
selection_box = board_box,
after_place_node = function(pos, placer, itemstack)
local meta = minetest.get_meta(pos)
meta:set_int("index", 1)
meta:set_string("formspec", formspec_help(meta, techage.manual_EN))
M(pos):set_string("infotext", "TA Construction Board (EN)")
M(pos):set_string("formspec", doclib.formspec(pos, "techage", "EN"))
end,
on_receive_fields = function(pos, formname, fields, player)
@ -194,19 +116,7 @@ minetest.register_node("techage:construction_board_EN", {
if minetest.is_protected(pos, player_name) then
return
end
local meta = minetest.get_meta(pos)
if fields.plan then
meta:set_string("formspec", formspec_plan(meta, techage.manual_EN))
elseif fields.back then
meta:set_string("formspec", formspec_help(meta, techage.manual_EN))
elseif fields.page then
local evt = minetest.explode_table_event(fields.page)
if evt.type == "CHG" then
local idx = tonumber(evt.row)
meta:set_int("index", idx)
meta:set_string("formspec", formspec_help(meta, techage.manual_EN))
end
end
M(pos):set_string("formspec", doclib.formspec(pos, "techage", "EN", fields))
end,
paramtype2 = "wallmounted",
@ -227,6 +137,45 @@ minetest.register_craft({
},
})
minetest.register_node("techage:construction_board_pt_BR", {
description = "TA Placa de construção (pt-BR)",
inventory_image = 'techage_constr_plan_inv.png',
tiles = {"techage_constr_plan.png"},
drawtype = "nodebox",
node_box = board_box,
selection_box = board_box,
after_place_node = function(pos, placer, itemstack)
M(pos):set_string("infotext", "TA Placa de construção (pt-BR)")
M(pos):set_string("formspec", doclib.formspec(pos, "techage", "pt-BR"))
end,
on_receive_fields = function(pos, formname, fields, player)
local player_name = player:get_player_name()
if minetest.is_protected(pos, player_name) then
return
end
M(pos):set_string("formspec", doclib.formspec(pos, "techage", "pt-BR", fields))
end,
paramtype2 = "wallmounted",
paramtype = "light",
use_texture_alpha = techage.CLIP,
sunlight_propagates = true,
is_ground_content = false,
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
sounds = default.node_sound_wood_defaults(),
})
minetest.register_craft({
output = "techage:construction_board_pt_BR",
recipe = {
{"default:stick", "default:stick", "default:paper"},
{"default:paper", "default:paper", "default:paper"},
{"default:paper", "default:paper", "default:paper"},
},
})
minetest.register_craft({
type = "shapeless",
output = "techage:construction_board_EN",
@ -236,5 +185,35 @@ minetest.register_craft({
minetest.register_craft({
type = "shapeless",
output = "techage:construction_board",
recipe = {"techage:construction_board_pt_BR"},
})
minetest.register_craft({
type = "shapeless",
output = "techage:construction_board_pt_BR",
recipe = {"techage:construction_board_EN"},
})
--
-- Legacy API functions
--
function techage.add_to_manual(language, titles, texts, items, plans)
local content = {titles = titles, texts = texts, images = items or {}, plans = plans or {}}
doclib.add_to_manual("techage", language, content)
end
function techage.add_manual_items(table_with_items)
for name, image in pairs(table_with_items) do
doclib.add_manual_image("techage", "EN", name, image)
doclib.add_manual_image("techage", "DE", name, image)
doclib.add_manual_image("techage", "pt-BR", name, image)
end
end
function techage.add_manual_plans(table_with_plans)
for name, plan in pairs(table_with_plans) do
doclib.add_manual_plan("techage", "EN", name, plan)
doclib.add_manual_plan("techage", "DE", name, plan)
doclib.add_manual_plan("techage", "pt-BR", name, plan)
end
end

View File

@ -12,7 +12,7 @@
]]--
techage.Items = {
local items = {
techage_ta1 = "techage_ta1.png",
iron = "techage:iron_ingot",
charcoal = "techage:charcoal",
@ -54,8 +54,8 @@ techage.Items = {
ta2_forceload = "techage:forceload",
ta2_driveaxle = "techage:axle",
ta2_generator = "techage:ta2_generator_off",
ta2_winch = "techage:ta2_winch",
ta2_weight_chest = "techage:ta2_weight_chest",
ta2_winch = "techage:ta2_winch",
ta2_weight_chest = "techage:ta2_weight_chest",
---------------------
techage_ta3 = "techage_ta3.png",
techage_ta31 = "techage_ta3b.png",
@ -110,12 +110,14 @@ techage.Items = {
ta3_logic = "techage:ta3_logic",
ta3_nodedetector = "techage:ta3_nodedetector_off",
ta3_playerdetector = "techage:ta3_playerdetector_off",
ta3_lightdetector = "techage:ta3_lightdetector_off",
ta3_repeater = "techage:ta3_repeater",
ta3_sequencer = "techage:ta3_sequencer",
ta3_timer = "techage:ta3_timer",
ta3_terminal = "techage:terminal2",
ta3_signallamp = "techage:signal_lamp_off",
ta3_colorlamp = "techage:color_lamp_off",
ta3_doorblock = "techage:doorblock20",
ta3_soundblock = "techage:ta3_soundblock",
ta3_programmer = "techage:programmer",
ta3_doorcontroller = "techage:ta3_doorcontroller",
ta3_drill_pipe_wrench = "techage:ta3_drill_pipe_wrench",
@ -125,6 +127,8 @@ techage.Items = {
ta3_valve = "techage:ta3_valve_closed",
ta3_motor = "techage:ta3_motor_off",
ta3_injector = "techage:ta3_injector_pas",
ta3_command_converter = "techage:ta3_command_converter_off",
ta3_flipflop = "techage:ta3_flipflop_off",
----------------------------
techage_ta4 = "techage_ta4.png",
techage_ta4c = "techage_ta4c.png",
@ -203,10 +207,14 @@ techage.Items = {
ta4_terminal = "techage:terminal3",
ta4_autocrafter = "techage:ta4_autocrafter_pas",
ta4_recipeblock = "techage:ta4_recipeblock",
ta4_chargedetector = "techage:ta4_chargedetector_off",
ta4_gaze_sensor = "techage:ta4_gaze_sensor_off",
ta4_nodedetector = "techage:ta4_nodedetector_off",
----------------------------
techage_ta5 = "techage:ta5_fr_nucleus",
ta5_flycontroller = "techage:ta5_flycontroller",
ta5_aichip = "techage:ta5_aichip",
ta5_aichip2 = "techage:ta5_aichip2",
ta5_tele_pipe = "techage:ta5_tele_pipe",
ta5_tele_tube = "techage:ta5_tele_tube",
ta5_chest = "techage:ta5_hl_chest",
@ -218,8 +226,8 @@ techage.Items = {
ta5_fr_controller = "techage:ta5_fr_controller_pas",
}
function techage.add_manual_items(table_with_items)
for name, tbl in pairs(table_with_items) do
techage.Items[name] = tbl
end
for name, image in pairs(items) do
doclib.add_manual_image("techage", "DE", name, image)
doclib.add_manual_image("techage", "EN", name, image)
doclib.add_manual_image("techage", "pt-BR", name, image)
end

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,39 +0,0 @@
--[[
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
API to add further chapters to the manuals
]]--
function techage.add_to_manual(language, titles, texts, items, plans)
local tbl
if language == "DE" then
tbl = techage.manual_DE
elseif language == "EN" then
tbl = techage.manual_EN
else
minetest.log("error", "[techage] Invalid manual language provided for 'techage.add_to_manual'!")
return
end
for _, item in ipairs(titles) do
tbl.aTitel[#tbl.aTitel + 1] = item
end
for _, item in ipairs(texts) do
tbl.aText[#tbl.aText + 1] = item
end
for _, item in ipairs(items) do
tbl.aItemName[#tbl.aItemName + 1] = item
end
for _, item in ipairs(plans) do
tbl.aPlanTable[#tbl.aPlanTable + 1] = item
end
end

152
doc/manual_pt-BR.lua Normal file
View File

@ -0,0 +1,152 @@
return {
titles = {
"1,Mod Tech Age",
"2,TA1: Idade do Ferro",
"2,TA2: Idade do Vapor",
"2,TA3: Idade do Petróleo",
"2,TA4: Tempos atuais (Presente)",
"2,TA5: Futuro",
"1,Dicas",
"1,Mudanças a partir da versão 1.0",
"2,Dicas sobre a troca",
"1,Minérios e Minerais",
"2,Meridium",
"2,Usmium",
"2,Baborium",
"2,Petróleo",
"2,Bauxita",
"2,Basalto",
"2,History",
},
texts = {
"O Tech Age é um mod de tecnologia com 5 estágios de desenvolvimento:\n"..
"\n",
"Utilize ferramentas e instrumentos auxiliares como queimadores de carvão\\, peneiras de cascalho\\, martelos e funis para extrair e processar minérios e metais necessários.\n"..
"\n",
"Construa uma máquina a vapor com eixos de transmissão e use-a para operar suas primeiras máquinas de processamento de minérios.\n"..
"\n",
"Encontre e extraia óleo\\, construa ferrovias para transporte de óleo. Uma usina fornece a eletricidade necessária para suas máquinas. A luz elétrica ilumina suas instalações industriais.\n"..
"\n",
"Fontes de energia renovável\\, como vento\\, sol e biocombustíveis\\, ajudam você a sair da era do petróleo. Com tecnologias modernas e máquinas inteligentes\\, você parte para o futuro.\n"..
"\n",
"Máquinas para superar espaço e tempo\\, novas fontes de energia e outras conquistas moldam sua vida.\n"..
"\n"..
"Nota: Clicando no sinal de adição\\, você acessa os subcapítulos deste manual.\n"..
"\n"..
"\n"..
"\n",
"Esta documentação está disponível tanto \"dentro do jogo\" (plano de construção de blocos) quanto no GitHub como arquivos MD.\n"..
"\n"..
" - Link: https://github.com/joe7575/techage/wiki\nOs planos de construção (diagramas) para a construção das máquinas e as imagens estão disponíveis apenas no jogo.\n"..
"\n"..
"Com o Tech Age\\, você precisa começar do zero. Você só pode criar blocos TA2 com os itens do TA1\\, para o TA3 você precisa dos resultados do TA2\\, e assim por diante.\n"..
"\n"..
"No TA2\\, as máquinas só funcionam com eixos de transmissão.\n"..
"\n"..
"A partir do TA3\\, as máquinas funcionam com eletricidade e têm uma interface de comunicação para controle remoto.\n"..
"\n"..
"O TA4 adiciona mais fontes de energia\\, mas também desafios logísticos mais altos (linhas de energia\\, transporte de itens).\n"..
"\n",
"A partir da V1.0 (17/07/2021)\\, as seguintes alterações foram feitas:\n"..
"\n"..
" - O algoritmo para calcular a distribuição de energia foi alterado. Isso torna os sistemas de armazenamento de energia mais importantes. Eles compensam as flutuações\\, o que é importante em redes maiores com vários geradores.\n"..
" - Por esse motivo\\, o TA2 recebeu seu próprio sistema de armazenamento de energia.\n"..
" - Os blocos de bateria do TA3 também servem como armazenamento de energia. Sua funcionalidade foi adaptada de acordo.\n"..
" - O sistema de armazenamento do TA4 foi revisado. O permutador de calor recebeu um novo número porque a funcionalidade foi movida do bloco inferior para o bloco central. Se eles estiverem sendo controlados remotamente\\, o número do nó deve ser adaptado. Os geradores não têm mais um menu próprio\\, mas são ligados/desligados apenas através do permutador de calor. O permutador de calor e o gerador agora devem estar conectados à mesma rede!\n"..
" - Vários sistemas de energia podem agora ser acoplados via blocos transformadores TA4.\n"..
" - Um novo bloco medidor de eletricidade TA4 para sub-redes também foi adicionado.\n"..
" - Pelo menos um bloco de bateria ou um sistema de armazenamento em cada rede.\n"..
"\n",
"Muitos outros blocos receberam alterações menores. Portanto\\, é possível que máquinas ou sistemas não reiniciem imediatamente após a troca. Em caso de falhas\\, as seguintes dicas ajudarão:\n"..
"\n"..
" - Desligue e ligue as máquinas novamente.\n"..
" - Remova um bloco de cabo de energia e coloque-o de volta no lugar.\n"..
" - Remova completamente o bloco e coloque-o de volta no lugar.\n"..
"\n",
"Techage adiciona novos itens ao jogo:\n"..
"\n"..
" - Meridium - uma liga para a produção de ferramentas luminosas no TA1\n"..
" - Usmium - um minério que é extraído no TA2 e necessário para o TA3\n"..
" - Baborium - um metal necessário para receitas no TA3\n"..
" - Petróleo - necessário no TA3\n"..
" - Bauxita - um minério de alumínio necessário no TA4 para produzir alumínio\n"..
" - Basalto - surge quando água e lava se encontram\n"..
"\n",
"O Meridium é uma liga de aço e cristais de mesecons. Lingotes de Meridium podem ser feitos com a caldeira a carvão a partir de aço e cristais de mesecons. O Meridium brilha no escuro. Ferramentas feitas de Meridium também emitem luz e são\\, portanto\\, muito úteis na mineração subterrânea.\n"..
"\n"..
"\n"..
"\n",
"O Usmium ocorre apenas como pepitas e só pode ser obtido lavando cascalho com o sistema de lavagem de cascalho TA2/TA3.\n"..
"\n"..
"\n"..
"\n",
"O Baborium só pode ser obtido através da mineração subterrânea. Essa substância só pode ser encontrada a uma profundidade de -250 a -340 metros.\n"..
"\n"..
"O Baborium só pode ser derretido na Fornalha Industrial TA3.\n"..
"\n"..
"\n"..
"\n",
"O Petróleo só pode ser encontrado com a ajuda do Explorer e extraído com a ajuda de máquinas apropriadas do TA3. Veja TA3.\n"..
"\n"..
"\n"..
"\n",
"A Bauxita é extraída apenas na mineração subterrânea. A Bauxita só é encontrada na pedra a uma altura entre -50 e -500 metros.\n"..
"É necessária para a produção de alumínio\\, que é principalmente usada no TA4.\n"..
"\n"..
"\n"..
"\n",
"O Basalto só é criado quando lava e água se encontram.\n"..
"A melhor coisa a fazer é montar um sistema onde uma fonte de lava e uma fonte de água se encontram.\n"..
"O Basalto é formado onde ambos os líquidos se encontram.\n"..
"Você pode construir um gerador automático de basalto com o Sign Bot.\n"..
"\n"..
"\n"..
"\n",
" - 28.09.2019: Solar system added\n"..
" - 05.10.2019: Data on the solar system and description of the inverter and the power terminal changed\n"..
" - 18.11.2019: Chapter for ores\\, reactor\\, aluminum\\, silo\\, bauxite\\, furnace heating\\, gravel washing system added\n"..
" - 22.02.2020: corrections and chapters on the update\n"..
" - 29.02.2020: ICTA controller added and further corrections\n"..
" - 14.03.2020 Lua controller added and further corrections\n"..
" - 22.03.2020 More TA4 blocks added\n"..
"\n",
},
images = {
"",
"",
"",
"",
"",
"techage_ta4",
"",
"",
"",
"",
"meridium",
"usmium",
"baborium",
"oil",
"bauxite",
"basalt",
"",
},
plans = {
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

172
doc/manual_ta1_DE.lua Normal file
View File

@ -0,0 +1,172 @@
return {
titles = {
"1,TA1: Eisenzeitalter",
"2,Köhler / Coal Pile",
"2,Kohlebrenner / Coal Burner",
"2,Wassermühle",
"3,TA1 Mühle",
"3,TA1 Schleusenschieber / TA1 Sluice Gate",
"3,TA1 Schleusengriff / TA1 Sluice Handle",
"3,TA1 Apfelholzbrett / TA1 Apple Wood Board",
"3,TA1 Apfel Mühlbachbrett / TA1 Apple Millrace Board",
"2,Erze und Werkzeuge",
"3,Hammer",
"3,Kiessieb / Gravel Sieve",
"3,Trichter / Hopper",
"3,Kies sieben mit dem Trichter",
"3,Meridium",
},
texts = {
"In TA1 geht es darum\\, mit einfachen Werkzeugen und Gerätschaften ausreichend Erze zu schürfen und Holzkohle herzustellen\\, so dass damit TA2 Maschinen hergestellt und betrieben werden können.\n"..
"\n"..
"Natürlich muss es für ein Eisenzeitalter auch Eisen geben und nicht nur Stahl (steel)\\, wie in \"Minetest Game\". Daher wurden einige Rezepte geändert\\, so dass zuerst Eisen hergestellt werden muss und erst später dann Stahl.\n"..
"\n"..
"Auch ist die Haltbarkeit der Werkzeuge an die Zeitalter angelehnt und entspricht damit nicht dem Minetest Originalspiel.\n"..
"Die Haltbarkeit/Härte bspw. für eine Axt ist:\n"..
"\n"..
" - Bronze: 20\n"..
" - Stahl: 30\n"..
"\n"..
"\n"..
"\n",
"Den Köhler brauchst du\\, um Holzkohle herzustellen. Holzkohle wird für den Brenner\\, aber auch bspw. in TA2 für die Dampfmaschine benötigt.\n"..
"\n"..
"Für den Köhler brauchst du:\n"..
"\n"..
" - einen Anzünderblock ('techage:lighter')\n"..
" - 26 Hölzblöcke (wood)\\, die zu einem Würfen aufgeschichtet werden. Die Holzsorte spielt keine Rolle.\n"..
" - Erde (dirt) um den Holzhaufen abzudecken.\n"..
" - Feuerstein und Eisen (technischer Name: 'fire:flint_and_steel') um den Anzünderblock anzuzünden.\n"..
"\n"..
"Bauanleitung (siehe auch Plan):\n"..
"\n"..
" - Baue eine 5x5 große Fläche aus Erde (dirt)\n"..
" - Platziere in die Mitte einen Anzünder (lighter)\n"..
" - Platziere rund um den Anzünder 7 Holz (wood)\\, aber lasse ein Loch zum Anzünder frei\n"..
" - Baue weitere 2 Schichten Holz darüber\\, so dass ein 3x3x3 großer Holzwürfel entsteht\n"..
" - Überdecke alles mit einer Schicht Erde zu einem 5x5x5 großen Würfel\\, aber lasse das Loch zum Anzünder frei\n"..
" - Entzünde den Anzünder und verschließe das Loch sofort mit jeweils einem Block Holz und Erde\n"..
" - Wenn du alles richtig gemacht hast\\, fängt der Köhler nach wenigen Sekunden an zu rauchen\n"..
" - Öffne den Köhler erst\\, wenn der Rauch verschwunden ist (ca. 20 min)\n"..
"\n"..
"Dann kannst du die 9 Holzkohleblöcke entnehmen und den Köhler erneut füllen.\n"..
"\n"..
"\n"..
"\n",
"Den Kohlebrenner benötigst du bspw. um Eisen und andere Erze im Schmelztiegel zu schmelzen. Es gibt verschiedene Rezepte\\, welche verschiedene Temperaturen benötigen. Je höher der Turm\\, um so heißer ist die Flamme. Eine Höhe von 11 Blöcken über der Bodenplatte ist für alle Rezepte ausreichend\\, ein Brenner mit dieser Höhe verbraucht aber auch mehr Holzkohle.\n"..
"\n"..
"Bauanleitung (siehe auch Plan):\n"..
"\n"..
" - Baue einen Turm aus Stein (cobble) mit einer 3x3 Grundfläche (7-11 Blöcke hoch)\n"..
" - Lasse unten ein Loch an einer Seite offen\n"..
" - Lege einen Anzünder (lighter) hinein\n"..
" - Fülle den Turm bis zum Rand mit Holzkohle\\, in dem du die Holzkohle von oben in das Loch fallen lässt\n"..
" - Entzünde den Anzünder durch das Loch\n"..
" - Platziere den Schmelztiegel oben auf dem Turm direkt in die Flamme\\, einen Block über dem Turmrand\n"..
" - Um den Brenner anzuhalten\\, schließe das Loch vorübergehend bspw. mit einem Erdblock.\n"..
"\n"..
"Der Schmelztiegel hat ein eigenes Menü mit Rezepten und ein Inventar\\, wo du die Erze hinein legst.\n"..
"\n"..
"\n"..
"\n",
"Mit der Wassermühle können Weizen und andere Getreide zu Mehl gemahlen und dann im Ofen zu Brot gebacken werden. Die Mühle wird mit\n"..
"Wasserkraft angetrieben. Dazu muss ein Mühlbach über einen Kanal zum Mühlrad geführt werden.\n"..
"Über eine Schleuse kann der Wasserfluss und damit das Mühlrad gesteuert werden.\n"..
"Die Schleuse besteht aus Schleusenschieber und Schleusengriff.\n"..
"\n"..
"Die Abbildung rechts (auf \"Plan\" klicken) zeigt den Aufbau der Wassermühle.\n"..
"\n"..
"\n"..
"\n",
"Mit der Wassermühle können Weizen und andere Getreide zu Mehl gemahlen und dann im Ofen zu Brot gebacken werden.\n"..
"Die Mühle muss mit einer TA1 Achse mit dem Mühlrad verbunden werden. Die Kraft des Mühlrades reicht nur für eine Mühle.\n"..
"\n"..
"Die Mühle kann mit Hilfe eines Minecart Hoppers automatisiert werden\\, so dass das Mehl bspw. direkt von der Mühle in einen Ofen befördert wird\\, um daraus Brot zu backen.\n"..
"\n"..
"\n"..
"\n",
"Der Schleusenschieber muss auf gleicher Höhe wie die Wasseroberfläche direkt an einen Teich oder in einen Bach gesetzt werden.\n"..
"Wird die Schleuse geöffnet\\, so fließt Wasser durch den Schieber. Dieses Wasser muss dann zum Mühlrad geleitet werden und treibt dort die Mühle an.\n"..
"\n"..
"\n"..
"\n",
"Der TA1 Schleusengriff muss auf den Schleusenschieber gesetzt werden. Mit Hilfe des Schleusengriffs (Rechtsklick) kann der Schieber geöffnet werden.\n"..
"\n"..
"\n"..
"\n",
"Block in verschiedenen Holzsorten zum Bauen des Mühlbachkanals. Es kann aber auch jedes andere Material verwendet werden.\n"..
"\n"..
"\n"..
"\n",
"Block in verschiedenen Holzsorten zum Bauen des Mühlbachkanals. Dieser Block eignet sich speziell in Verbindung mit den Pfosten des Holzzauns um eine Stütze für den Kanal zu bauen.\n"..
"\n"..
"\n"..
"\n",
"TA1 hat seine eigenen Werkzeuge wie Hammer und Kiessieb\\, aber auch der Minecart Hopper kann genutzt werden.\n"..
"\n"..
"\n"..
"\n",
"Mit dem TA1 Hammer können Steine (stone) und Kopfsteinpflaster-Steine (cobble) zu Kies (gravel) zertrümmert werden. Der Hammer ist in verschiedenen Ausführungen und damit verschiedenen Eigenschaften verfügbar: Bronze\\, Stahl\\, Mese und Diamant.\n"..
"\n"..
"\n"..
"\n",
"Mit dem Kiessieb können Erze aus dem Kies gesiebt werden. Dazu mit dem Kies (gravel) auf das Sieb klicken. Der gesiebte Kies und die Erze fallen unten heraus.\n"..
"\n"..
"Um hier nicht stundenlang am Sieb zu stehen\\, kann das Sieben mit dem Trichter (hopper) automatisiert werden.\n"..
"\n"..
"\n"..
"\n",
"Der Hopper aus der Mod \"Minecart\" dient in erster Linie zum Be- und Entladen von Minecarts. Er saugt Gegenstände (items) von oben ein und gibt diese nach rechts weiter. Beim Platzieren des Trichters muss daher auf die Ausgaberichtung geachtet werden.\n"..
"\n"..
"Der Trichter kann aber auch Items aus Kisten (chest) ziehen\\, sofern die Kiste neben oder auf dem Trichter steht. \n"..
"\n"..
"Der Trichter kann auch Items in Kisten legen\\, sofern die Kiste neben dem Trichter steht.\n"..
"\n"..
"\n"..
"\n",
"Mit Hilfe von zwei Kisten\\, zwei Trichtern und einem Kiessieb kann der Siebevorgang automatisiert werden. Der Plan rechts zeigt den Aufbau.\n"..
"\n"..
"Bei den Kisten darauf achten\\, dass es die \"chest_locked\" ist\\, sonst klaut dir jemand die wertvollen Erze aus der Kiste unten.\n"..
"\n"..
"\n"..
"\n",
"TA1 hat seine eigene Metalllegierung Meridium. Meridium Ingots können mit dem Kohlebrenner aus Stahl und Mesesplittern hergestellt werden. Meridium leuchtet im Dunkeln. Auch Werkzeuge aus Meridium leuchten und sind daher im Untertagebau sehr hilfreich.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta1",
"",
"",
"",
"",
"ta1_sluice",
"ta1_sluice_handle",
"ta1_board1",
"ta1_board2",
"ta1_gravelsieve",
"hammer",
"ta1_gravelsieve",
"ta1_hopper",
"",
"meridium",
},
plans = {
"",
"coalpile",
"coalburner",
"watermill1",
"watermill2",
"",
"",
"",
"",
"",
"",
"",
"",
"hoppersieve",
"",
}
}

170
doc/manual_ta1_EN.lua Normal file
View File

@ -0,0 +1,170 @@
return {
titles = {
"1,TA1: Iron Age",
"2,Charcoal Pile (charcoal burner)",
"2,Melting Furnace",
"2,Watermill",
"3,TA1 mill",
"3,TA1 sluice gate",
"3,TA1 sluice handle",
"3,TA1 Apple Wood Board",
"3,TA1 Apple Millrace Board",
"2,Ores and Tools",
"3,Hammer",
"3,Gravel Sieve",
"3,Hopper",
"3,Gravel seven with the hopper",
"3,Meridium",
},
texts = {
"TA1 is about mining sufficient ores and producing charcoal with simple tools and equipment\\, so that TA2 machines can be manufactured and operated.\n"..
"\n"..
"Of course\\, for an iron age there must also be iron and not just steel\\, as in \"Minetest Game\". As a result\\, some recipes have been changed so that iron has to be produced first and then steel later.\n"..
"\n"..
"The durability of the tools is based on the ages and therefore does not correspond to the original Minetest game.\n"..
"The durability / hardness for an axe\\, for example:\n"..
"\n"..
" - Bronze: 20\n"..
" - Steel: 30\n"..
"\n"..
"\n"..
"\n",
"You need the Charcoal Pile to make charcoal. Charcoal is required for the melting furnace\\, but also\\, for example\\, in TA2 for the steam engine.\n"..
"\n"..
"For the charcoal burner you need:\n"..
"\n"..
" - a lighter block ('techage:lighter')\n"..
" - 26 wooden blocks that are stacked into a pile of wood. The type of wood is irrelevant\n"..
" - Dirt to cover the pile of wood\n"..
" - Flint and Iron (technical name: 'fire:flint_and_steel') to light the lighter block\n"..
"\n"..
"Building instructions (see also plan):\n"..
"\n"..
" - Build a 5x5 area of dirt\n"..
" - Place 7 wood around the lighter but leave a hole to the lighter\n"..
" - Build another 2 layers of wood on top\\, making a 3x3x3 wooden cube\n"..
" - Cover everything with a layer of dirt into a 5x5x5 cube\\, but keep the hole to the lighter open\n"..
" - Light the lighter and immediately close the hole with a block of wood and dirt\n"..
" - If you have done everything correctly\\, the coal burner will start smoking after a few seconds\n"..
" - Only open the charcoal burner when the smoke has disappeared (approx. 20 min)\n"..
"\n"..
"Then you can remove the 9 charcoal blocks and refill the Charcoal Pile.\n"..
"\n"..
"\n"..
"\n",
"You need the melting furnace\\, for example\\, to melt iron and other ores in the melting pot. There are different recipes that require different temperatures. The higher the melting tower\\, the hotter the flame. A height of 11 blocks above the base plate is for all recipes\\, but a burner with this height also requires more charcoal.\n"..
"\n"..
"Building instructions (see also plan):\n"..
"\n"..
" - Build a stone tower (cobble) with a 3x3 base (7-11 blocks high)\n"..
" - Leave a hole open on one side at the bottom\n"..
" - Put a lighter in it\n"..
" - Fill the tower to the brim with charcoal by dropping the charcoal into the hole from above\n"..
" - Light the lighter through the hole\n"..
" - Place the melting pot on top of the tower directly into the flame\\, one block above the tower edge\n"..
" - To stop the burner\\, temporarily close the hole with an dirt block\\, for example.\n"..
"\n"..
"The melting pot has its own menu of recipes and an inventory where you have to put the ores in.\n"..
"\n"..
"\n"..
"\n",
"The watermill can be used to grind wheat and other grains into flour and then bake them in the furnace to make bread. \n"..
"The mill is powered by water power. To do this\\, a millrace must be led to the mill wheel via a canal.\n"..
"The water flow and thus the mill wheel can be controlled via a sluice. The sluice consists of the sluice lock and sluice handle.\n"..
"\n"..
"The picture on the right (click on \"Plan\") shows the structure of the watermill. \n"..
"\n"..
"\n"..
"\n",
"The watermill can be used to grind wheat and other grains into flour and then bake them in the oven to make bread. The mill must be connected to the mill wheel with a TA1 axle. The power of the mill wheel is only enough for one mill.\n"..
"\n"..
"The mill can be automated with the help of a Minecart Hopper\\, so that the flour\\, for example\\, is transported directly from the mill into an furnace in order to bake bread from it.\n"..
"\n"..
"\n"..
"\n",
"The sluice gate valve must be placed directly next to a pond or in a stream at the same height as the water surface.\n"..
"When the gate is opened\\, water flows through the slide. This water then has to be fed to the mill wheel\\, where it drives the mill.\n"..
"\n"..
"\n"..
"\n",
"The TA1 sluice handle must be placed on the sluice gate. The gate can be opened with the aid of the sluice handle (right click).\n"..
"\n"..
"\n"..
"\n",
"Block in different types of wood for building the millrace canal. However\\, any other material can also be used.\n"..
"\n"..
"\n"..
"\n",
"Block in different types of wood for building the millrace canal. This block is especially suitable in connection\n"..
"with posts of the wooden fence to build a support of the canal.\n"..
"\n"..
"\n"..
"\n",
"TA1 has its own tools such as hammer and gravel sieve\\, but the Minecart Hopper can also be used.\n"..
"\n"..
"\n"..
"\n",
"The TA1 hammer can be used to knock/dig stone in a mine\\, but also to smash cobble to gravel. The hammer is available in different versions and therefore different properties: bronze\\, steel\\, brass and diamond.\n"..
"\n"..
"\n"..
"\n",
"Ores can be sifted from the gravel with the gravel sieve. To do this\\, click on the sieve with the gravel. The sifted gravel and ores fall out below.\n"..
"\n"..
"In order not to stand at the sieve for hours\\, sieving can be automated with the hopper.\n"..
"\n"..
"\n"..
"\n",
"The hopper from the \"Minecart\" mod is primarily used for loading and unloading Minecarts. He sucks in items from above and passes them on to the right. Therefore\\, when placing the hopper\\, pay attention to the direction of dispensing.\n"..
"\n"..
"The hopper can also pull items from boxes (chest)\\, provided the box is next to or on the hopper.\n"..
"\n"..
"The hopper can also put items in boxes if the box is next to the hopper.\n"..
"\n"..
"\n"..
"\n",
"With the help of two boxes\\, two hoppers and a gravel sieve\\, the sieving process can be automated. The plan on the right shows the structure.\n"..
"\n"..
"Make sure that the boxes are \"chest_locked\"\\, otherwise someone will steal the valuable ores from the box below.\n"..
"\n"..
"\n"..
"\n",
"TA1 has its own metal alloy meridium. Meridium ingots can be made with the coal burner from steel and mesecons crystals. Meridium glows in the dark. Tools made of Meridium also light up and are therefore very helpful in underground mining.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta1",
"",
"",
"",
"",
"ta1_sluice",
"ta1_sluice_handle",
"ta1_board1",
"ta1_board2",
"ta1_gravelsieve",
"hammer",
"ta1_gravelsieve",
"ta1_hopper",
"",
"meridium",
},
plans = {
"",
"coalpile",
"coalburner",
"watermill1",
"watermill2",
"",
"",
"",
"",
"",
"",
"",
"",
"hoppersieve",
"",
}
}

153
doc/manual_ta1_pt-BR.lua Normal file
View File

@ -0,0 +1,153 @@
return {
titles = {
"1,TA1: Idade do Ferro",
"2,Pilha de Carvão (queimador de carvão)",
"2,Forno de Fundição",
"2,Moinho d'Água",
"3,Moinho d'Água TA1",
"3,Comporta TA1",
"3,Alavanca de Comporta TA1",
"3,Placa de Madeira de Maçã TA1",
"3,Placa de Curso d'Água de Maçã TA1",
"1,Minérios e Ferramentas",
"2,Martelo",
"2,Peneira de Cascalho(Sieve)",
"2,Funil (Minecart Hopper)",
"2,Peneirando sete cascalhos com Funil",
},
texts = {
"TA1 trata da extração de minérios suficientes e da produção de carvão com ferramentas e equipamentos simples\\, para que as máquinas TA2 possam ser fabricadas e operadas.\n"..
"\n"..
"É claro que\\, para uma Idade do Ferro\\, deve haver ferro e não apenas aço\\, como em \"Minetest Game\". Como resultado\\, algumas receitas foram alteradas para que o ferro precise ser produzido primeiro e\\, posteriormente\\, o aço.\n"..
"\n"..
"A durabilidade das ferramentas é baseada nas eras e\\, portanto\\, não corresponde ao jogo original do Minetest.\n"..
"A durabilidade/dureza de um machado\\, por exemplo:\n"..
"\n"..
" - Bronze: 20\n"..
" - Aço: 30\n"..
"\n"..
"\n"..
"\n",
"Você precisa da Pilha de Carvão para fazer carvão. O carvão é necessário para a fundição\\, mas também\\, por exemplo\\, em TA2 para a máquina a vapor.\n"..
"\n"..
"Para o queimador de carvão\\, você precisa de:\n"..
"\n"..
" - Um bloco de acendedor ('techage:lighter')\n"..
" - 26 blocos de madeira empilhados para formar um monte de madeira. O tipo de madeira é irrelevante.\n"..
" - Terra para cobrir o monte de madeira\n"..
" - Pedra lascada e Ferro (nome técnico: 'fire:flint_and_steel') para acender o bloco de acendedor\n"..
"\n"..
"Instruções de construção (veja também o plano):\n"..
"\n"..
" - Construa uma área de 5x5 de terra\n"..
" - Coloque 7 blocos de madeira ao redor do acendedor\\, mas deixe um buraco para o acendedor\n"..
" - Construa mais 2 camadas de madeira em cima\\, formando um cubo de madeira 3x3x3\n"..
" - Cubra tudo com uma camada de terra formando um cubo de 5x5x5\\, mas mantenha o buraco para o acendedor aberto\n"..
" - Acenda utilizando o isqueiro e feche imediatamente o buraco com um bloco de madeira e terra\n"..
" - Se você fez tudo corretamente\\, o queimador de carvão começará a soltar fumaça após alguns segundos\n"..
" - Só abra o queimador de carvão quando a fumaça tiver desaparecido (aproximadamente 20 minutos)\n"..
" - Então você pode remover os 9 blocos de carvão e reabastecer a Pilha de Carvão.\n"..
"\n"..
"\n"..
"\n",
"Você precisa do forno de fundição\\, por exemplo\\, para fundir ferro e outros minérios no Vaso de fundição(cadinho). Existem receitas diferentes que requerem diferentes temperaturas. Quanto mais alto a torre de fusão\\, mais quente é a chama. Uma altura de 11 blocos acima da placa base é para todas as receitas\\, mas um queimador com essa altura também requer mais carvão.\n"..
"\n"..
"Instruções de construção (veja também o plano):\n"..
"\n"..
" - Construa uma torre de pedregulho (cobble) com uma base de 3x3 (7-11 blocos de altura)\n"..
" - Deixe um buraco aberto de um lado na parte inferior\n"..
" - Coloque um acendedor nele\n"..
" - Encha a torre até a borda com carvão despejando o carvão no buraco de cima para baixo\n"..
" - Acenda o acendedor através do buraco\n"..
" - Coloque o Vaso de fundição(cadinho) no topo da torre diretamente na chama\\, um bloco acima da borda da torre\n"..
" - Para parar o queimador\\, feche temporariamente o buraco com um bloco de terra\\, por exemplo.\n"..
" - O Vaso de fundição(cadinho) tem seu próprio menu de receitas e um inventário onde você precisa colocar os minérios.\n"..
"\n"..
"\n"..
"\n",
"O moinho d'água pode ser usado para moer trigo e outros grãos para fazer farinha e depois assá-los no forno para fazer pão.\n"..
"O moinho é alimentado por energia hidráulica. Para isso\\, um curso de água deve ser conduzido até a roda do moinho através de um canal.\n"..
"O fluxo de água e\\, portanto\\, a roda do moinho\\, podem ser controlados por meio de uma comporta. A comporta é composta pelo bloqueio de comporta e pela alavanca de comporta.\n"..
"\n"..
"A imagem à direita (clique em \"Plano\") mostra a estrutura do moinho d'água.\n"..
"\n"..
"\n"..
"\n",
"O moinho d'água pode ser usado para moer trigo e outros grãos para fazer farinha e depois assá-los no forno para fazer pão. O moinho deve ser conectado à roda do moinho com um eixo TA1. A potência da roda do moinho é apenas suficiente para um moinho.\n"..
"\n"..
"O moinho pode ser automatizado com a ajuda de um Funil(Minecart Hopper)\\, para que a farinha\\, por exemplo\\, seja transportada diretamente do moinho para um forno para assar pão.\n"..
"\n"..
"\n"..
"\n",
"A válvula de comporta deve ser colocada diretamente ao lado de um lago ou em um riacho na mesma altura que a superfície da água.\n"..
"Quando a comporta é aberta\\, a água flui através do canal. Essa água deve ser conduzida até a roda do moinho\\, onde movimenta o moinho.\n"..
"\n"..
"\n"..
"\n",
"A alavanca de comporta TA1 deve ser colocada na comporta. A comporta pode ser aberta com a ajuda da alavanca de comporta (clique com o botão direito).\n"..
"\n"..
"\n"..
"\n",
"Podem ser usados bloco de diferentes tipos de madeira para construir o canal do curso d'água. No entanto\\, qualquer outro material também pode ser usado.\n"..
"\n"..
"\n"..
"\n",
"Podem ser utilizados blocos em diferentes tipos de madeira para construir o canal do curso d'água. Este bloco é especialmente adequado em conexão com postes da cerca de madeira para construir um suporte do canal.\n"..
"\n"..
"\n"..
"\n",
"O TA1 possui suas próprias ferramentas\\, como martelo e peneira de cascalho\\, mas o Funil(Minecart Hopper) também pode ser utilizado.\n"..
"\n",
"O martelo TA1 pode ser utilizado para bater/escavar pedra em uma mina\\, mas também para quebrar pedregulho(cobble) em cascalho(gravel). O martelo está disponível em diferentes versões\\, cada uma com propriedades distintas: bronze\\, aço\\, latão e diamante.\n"..
"\n",
"Minérios podem ser peneirados do cascalho com a peneira de cascalho. Para fazer isso\\, clique na peneira com o cascalho. O cascalho peneirado e os minérios caem abaixo.\n"..
"\n"..
"Para não ficar horas na peneira\\, é possível automatizar o processo com o Funil(Minecart Hopper).\n"..
"\n",
"O funil do mod \"Minecart Hopper\" é utilizado principalmente para carregar e descarregar carrinhos de mineração. Ele suga itens de cima e os passa para a direita. Portanto\\, ao posicionar o funil\\, preste atenção na direção de dispensa.\n"..
"\n"..
"O funil também pode puxar itens de baús\\, desde que a caixa esteja ao lado ou em cima do funil.\n"..
"\n"..
"O funil também pode colocar itens em baús se a caixa estiver ao lado do funil.\n"..
"\n",
"Com a ajuda de dois baús\\, dois funis e uma peneira de cascalho\\, o processo de peneiração pode ser automatizado. O plano à direita mostra a estrutura.\n"..
"\n"..
"Certifique-se de que os baús são protegidos\\, caso contrário\\, alguém pode roubar os minérios valiosos do baú abaixo.\n"..
"\n"..
"Meridium\n"..
"O TA1 possui sua própria liga metálica\\, o Meridium. Lingotes de meridium podem ser feitos com a caldeira a carvão\\, utilizando aço e cristais de mesecons. O meridium brilha no escuro. Ferramentas feitas de meridium também emitem luz\\, sendo\\, portanto\\, muito úteis na mineração subterrânea.\n"..
"\n",
},
images = {
"techage_ta1",
"",
"",
"",
"",
"ta1_sluice",
"ta1_sluice_handle",
"ta1_board1",
"ta1_board2",
"",
"",
"",
"",
"",
},
plans = {
"",
"coalpile",
"coalburner",
"watermill1",
"watermill2",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

308
doc/manual_ta2_DE.lua Normal file
View File

@ -0,0 +1,308 @@
return {
titles = {
"1,TA2: Dampfzeitalter",
"2,Dampfmaschine",
"3,TA2 Feuerbox / Firebox",
"3,TA2 Boiler",
"3,TA2 Zylinder /Cylinder",
"3,TA2 Schwungrad / Flywheel",
"3,TA2 Dampfleitungen / Steam Pipe",
"3,TA2 Antriebsachsen / TA2 Drive Axle",
"3,TA2 Stromgenerator / TA2 Power Generator",
"2,TA2 Energiespeicher",
"3,TA2 Seilwinde / TA2 Winch",
"3,TA2 Gewichtekiste / TA2 Weight Chest",
"3,TA2 Kupplung / TA2 Clutch",
"2,Items schieben und sortieren",
"3,Röhren / TechAge Tube",
"3,Röhren Konzentrator / Tube Concentrator",
"3,TA2 Schieber / Pusher",
"3,TA2 Verteiler / Distributor",
"2,Kieswaschanlage",
"3,TA2 Kiesspüler / Gravel Rinser",
"2,Stein brechen\\, mahlen und sieben",
"3,TA2 Steinbrecher / Quarry",
"3,TA2 Mühle / Grinder",
"3,TA2 Kiessieb / Gravel Sieve",
"2,Items produzieren",
"3,TA2 Autocrafter",
"3,TA2 Elektronikfabrik / Electronic Fab",
"2,Sonstige Blöcke",
"3,TA2 Flüssigkeitensammler / Liquid Sampler",
"3,TA2 Gesicherte Kiste / Protected Chest",
"3,Techage Forceload Block",
},
texts = {
"In TA2 geht es darum\\, erste Maschinen zur Verarbeitung von Erzen zu bauen und zu betreiben. Einige Maschinen müssen dazu über Antriebsachsen angetrieben werden. Dazu musst du eine Dampfmaschine bauen und diese mit Kohle oder Holzkohle anheizen.\n"..
"\n"..
"In TA2 steht auch ein Kiesspüler zur Verfügung\\, mit dem seltene Erze wie Usmium Nuggets ausgewaschen werden können. Diese Nuggets wirst du später für weitere Rezepte brauchen.\n"..
"\n"..
"\n"..
"\n",
"Die Dampfmaschine besteht aus mehreren Blöcken und muss wie im Plan rechts abgebildet\\, zusammen gebaut werden. Dazu werden die Blöcke TA2 Feuerbox\\, TA2 Boiler oben\\, TA2 Boiler unten\\, TA2 Zylinder\\, TA2 Schwungrad und Dampfleitungen benötigt.\n"..
"\n"..
"Zusätzlich werden Antriebsachsen sowie Getriebeblöcke für Richtungswechsel benötigt. Das Schwungrad muss über die Antriebsachsen mit allen Maschinen verbunden werden\\, die angetrieben werden müssen.\n"..
"\n"..
"Bei allen Blöcken beim Setzen immer auch die Ausrichtung achten:\n"..
"\n"..
" - Zylinder links\\, Schwungrad rechts daneben\n"..
" - Dampfleitungen anschließen\\, wo ein entsprechendes Loch ist\n"..
" - Antriebsachse beim Schwungrad nur rechts\n"..
" - bei allen Maschinen kann die Antriebsachse an allen Seiten angeschlossen werden\\, welche nicht durch andere Funktionen belegt wird\\, wie bspw. die IN und OUT Löcher bei Mühle und Sieb.\n"..
"\n"..
"Der Boiler muss mit Wasser gefüllt werden. Dazu bis zu 10 Eimer Wasser in den Boiler füllen.\n"..
"Die Feuerbox muss mit Kohle oder Holzkohle gefüllt werden.\n"..
"Wenn das Wasser heiß ist (Temperaturanzeige ganz oben)\\, kann die Dampfmaschine am Schwungrad gestartet werden.\n"..
"\n"..
"Die Dampfmaschine leistet 25 ku und kann damit mehrere Maschinen gleichzeitig antreiben.\n"..
"\n"..
"\n"..
"\n",
"Teil der Dampfmaschine. \n"..
"\n"..
"Die Feuerbox muss mit Kohle oder Holzkohle gefüllt werden. Die Brenndauer ist abhängig von der Leistung\\, die von der Dampfmaschine angefordert wird. Unter Volllast brennt Kohle 32 s und Holzkohle 96 s.\n"..
"\n"..
"\n"..
"\n",
"Teil der Dampfmaschine. Muss mit Wasser gefüllt werden. Dies erfolgt durch Klicken mit einem Wassereimer auf den Boiler. Wenn kein Wasser mehr vorhanden ist oder die Temperatur zu weit absinkt\\, schaltet sich die Dampfmaschine ab. Bei der Dampfmaschine geht bei jedem Kolbenhub etwas Wasser als Dampf verloren\\, daher muss regelmäßig Wasser nachgefüllt werden.\n"..
"\n"..
"\n"..
"\n",
"Teil der Dampfmaschine.\n"..
"\n"..
"\n"..
"\n",
"Antriebsteil der Dampfmaschine. Das Schwungrad muss über Antriebsachsen mit den Maschinen verbunden werden. \n"..
"\n"..
"\n"..
"\n",
"Teil der Dampfmaschine. Der Boiler muss mit dem Zylinder über die Dampfleitungen (steam pipes) verbunden werden. Die Dampfleitung besitzt keine Abzweigungen\\, die maximale Länge beträgt 12 m (Blöcke).\n"..
"\n"..
"\n"..
"\n",
"Die Antriebsachsen dienen zur Kraftübertragung von der Dampfmaschine zu anderen Maschinen. Die maximale Länge einer Antriebsachse beträgt 10 Blöcke. Über Getriebeblöcke können auch größere Strecken überbrückt\\, sowie Abzweigungen und Richtungswechsel realisiert werden.\n"..
"\n"..
"\n"..
"\n",
"Um Lampen oder andere Stromverbraucher an einer Dampfmaschine betreiben zu können\\, wird der TA2 Stromgenerator benötigt. Der TA2 Stromgenerator muss auf einer Seite mit Antriebsachsen verbunden werden und liefert dann auf der anderen Seite elektrischen Strom.\n"..
"\n"..
"Wird der Stromgenerator nicht mit ausreichend Kraft versorgt\\, geht er in einen Fehlerzustand und muss über einen Rechtsklick wieder aktiviert werden.\n"..
"\n"..
"Das Stromgenerator nimmt primär max. 25 ku an Achsenkraft auf und gibt sekundär max. 24 ku als Strom wieder ab. Er verbraucht also ein ku für die Umwandlung.\n"..
"\n"..
"\n"..
"\n",
"Bei größeren Anlagen mit mehreren Dampfmaschinen oder vielen angetriebenen Maschinen empfiehlt sich ein Energiespeicher. Der Energiespeicher bei TA2 arbeitet mit Lageenergie. Dazu wird Balast (Steine\\, Kies) in einer Kiste mit Hilfe einer Seilwinde in die Höhe gezogen. Ist überschüssige Energie im Achsen-Netzwerk vorhanden\\, so wird die Kiste nach oben gezogen. Wird kurzfristig mehr Energie benötigt\\, als die Dampfmaschine liefern kann\\, so gibt der Energiespeicher die gespeicherte Energie wieder ab\\, und die Balast-Kiste bewegt sich wieder nach unten.\n"..
"\n"..
"Der Energiespeicher besteht aus mehreren Blöcken und muss wie im Plan rechts abgebildet\\, zusammen gebaut werden.\n"..
"\n"..
"Um die maximale Speicherkapazität zu erreichen\\, muss die Kiste mit Gewichten komplett gefüllt\\, und der Mast inklusive der zwei Getriebeblöcke 12 Blöcke hoch sein. Kleinere Aufbauten sind aber auch möglich.\n"..
"\n"..
"\n"..
"\n",
"Die Seilwinde muss mit einem Getriebeblock verbunden werden und kann so überschüssige Energie aufnehmen und damit eine Gewichtekiste nach oben ziehen. Achte beim Aufbau der Seilwinde darauf\\, dass der Pfeil auf der Blockoberseite zum Getriebeblock zeigt. Die maximale Seillänge beträgt 10 Blöcke.\n"..
"\n"..
"\n"..
"\n",
"Diese Kiste muss mit bis zu 10 Blöcken Abstand unter die Seilwinde gesetzt und mit Pflastersteinen Kies oder Sand gefüllt werden. Ist das Mindestgewicht von einem Stack (99+ Items) erreicht und überschüssige Energie vorhanden\\, wird die Kiste automatisch über eine Seil mit der Seilwinde verbunden und in die Höhe gezogen.\n"..
"\n"..
"\n"..
"\n",
"Mit der Kupplung können Achsen und Maschinen vom Energiespeicher getrennt werden. Damit kommen die Achsen nach der Kupplung zum Stillstand und Maschinenanlagen können umgebaut werden. Achte beim Aufbau der Kupplung darauf\\, dass der Pfeil auf der Blockoberseite zum Energiespeicher zeigt. \n"..
"\n"..
"\n"..
"\n",
"Um Gegenstände (Items) von einer Verarbeitungsstation zur nächsten weiter zu transportieren\\, werden Schieber und Röhren verwendet. Siehe Plan.\n"..
"\n"..
"\n"..
"\n",
"Zwei Maschinen können mit Hilfe eines Schiebers und einer Röhre (tube) verbunden werden. Röhren besitzen keine Abzweigungen. Die maximale Länge beträgt 200 m (Blöcke).\n"..
"\n"..
"Röhren können alternativ mit Hilfe der Shift-Taste platziert werden. Dies erlaubt bspw. Röhren parallel zu verlegen\\, ohne dass diese sich unbeabsichtigt verbinden.\n"..
"\n"..
"Die Transportkapazität einer Röhre ist unbegrenzt und nur durch die Schieber begrenzt.\n"..
"\n"..
"\n"..
"\n",
"Über den Konzentrator können mehrere Röhren zu einer Röhre zusammengeführt werden. Die Richtung\\, in der alle Items weitergegeben werden\\, ist mit einem Pfeil markiert.\n"..
"\n"..
"\n"..
"\n",
"Ein Schieber ist in der Lage\\, Items aus Kisten oder Maschinen zu ziehen und in andere Kisten oder Maschinen zu schieben. Oder anders gesagt: Zwischen zwei Blöcken mit Inventar muss ein und genau ein Schieber sein. Mehrere Schieber in Reihe sind nicht möglich.\n"..
"In die Gegenrichtung ist ein Schieber für Items aber durchlässig\\, so dass eine Kiste über eine Röhre gefüllt und ebenso geleert werden kann. \n"..
"\n"..
"Ein Schieber geht in den Zustand \"standby\"\\, wenn der keine Items zum Schieben hat. Ist der Ausgang blockiert oder das Inventory des Empfängers voll\\, so geht der Schieber in den Zustand \"blocked\". Aus beiden Zuständen kommt der Schieber nach einigen Sekunden selbsttätig wieder raus\\, sofern sich die Situation geändert hat.\n"..
"\n"..
"Der Verarbeitungsleistung eines TA2 Schiebers beträgt 2 Items alle 2 s.\n"..
"\n"..
"\n"..
"\n",
"Der Verteiler ist in der Lage\\, die Items aus seinem Inventar sortiert in bis zu vier Richtungen weiter zu transportieren. Dazu muss der Verteiler entsprechend konfiguriert werden. \n"..
"\n"..
"Der Verteiler besitzt dazu ein Menü mit 4 Filter mit unterschiedlichen Farben\\, entsprechend den 4 Ausgängen. Soll ein Ausgang genutzt werden\\, so muss der entsprechende Filter über die \"on\" Checkbox aktiviert werden. Alle Items\\, die für diesen Filter konfiguriert sind\\, werden über den zugeordneten Ausgang ausgegeben. Wird ein Filter aktiviert\\, ohne das Items konfiguriert werden\\, so sprechen wir hier von einem \"nicht-konfigurierten\"\\, offenen Ausgang.\n"..
"\n"..
"*Achtung: Der Verteiler ist an seinen Ausgängen gleichzeitig ein Schieber. Daher niemals die Gegenstände mit einem Schieber aus dem Verteiler ziehen!*\n"..
"\n"..
"Für einen nicht-konfigurierten Ausgang gibt es zwei Betriebsarten:\n"..
"\n"..
"1) Alle Items ausgeben\\, die an keine anderen Ausgängen ausgegeben werden können\\, auch wenn diese blockiert sind.\n"..
"\n"..
"2) Nur die Items ausgeben\\, die für keinen anderen Filter konfiguriert wurden.\n"..
"\n"..
"Im ersten Fall werden immer alle Items weitergeleitet und der Verteiler läuft nicht voll. Im zweiten Fall werden Items zurückgehalten und der Verteiler kann voll laufen und in der Folge blockieren.\n"..
"\n"..
"Einstellbar ist die Betriebsart über die \"blockiere\" Checkbox.\n"..
"\n"..
"Der Verarbeitungsleistung eines TA2 Verteilers beträgt 4 Items alle 2 s\\, wobei der Verteiler dabei versucht\\, die 4 Items auf die offenen Ausgänge zu verteilen.\n"..
"\n"..
"Wird dasselbe Item in einem Filter mehrfach hinterlegt\\, so beeinflusst dies das langfristige Verteilungsverhältnis entsprechend.\n"..
"\n"..
"Bitte beachte\\, dass die Verteilung ein probabilistischer Vorgang ist\\, d.h. die Verhältnisse werden nicht exakt\\, sondern nur langfristig eingehalten.\n"..
"\n"..
"In den Filtern beträgt die maximale Stackgröße 12\\; insgesamt können höchstens 36 Items konfiguriert werden.\n"..
"\n"..
"\n"..
"\n",
"Die Kieswaschanlage ist eine komplexere Maschine mit dem Ziel\\, Usmium Nuggets aus gesiebtem Kies auszuwaschen. Für den Aufbau wird ein TA2 Kiesspüler mit Achsenantrieb\\, ein Trichter\\, eine Kiste\\, sowie fließendes Wasser benötigt. \n"..
"\n"..
"Aufbau von links nach rechts (siehe auch Plan):\n"..
"\n"..
" - Ein Erdblock\\, darauf die Wasserquelle\\, umgeben auf 3 Seiten von bspw. Glasblöcken\n"..
" - daneben den Kiesspüler\\, ggf. mit Röhrenanschlüssen für den Kies An- und Abtransport\n"..
" - dann den Trichter mit Kiste\n"..
"\n"..
"Das Ganze umgeben von weiteren Glasblöcken\\, so dass das Wasser über den Kiesspüler und den Trichter fließt und ausgespülten Nuggets vom Trichter wieder eingesammelt werden können.\n"..
"\n"..
"\n"..
"\n",
"Der Kiesspüler ist in der Lage\\, aus bereits gesiebtem Kies die Erze Usmium und Kupfer auszuspülen\\, sofern dieser von Wasser überspült wird.\n"..
"\n"..
"Ob der Kiesspüler korrekt arbeitet\\, kann mit Hilfe von Stöcken (sticks) getestet werden\\, wenn diese in das Inventar des Kiesspülers getan werden. Diese müssen einzeln ausgespült und vom Trichter eingefangen werden.\n"..
"\n"..
"Die Verarbeitungsleistung ist ein Kies Item alle 2 s. Der Kiesspüler benötigt 3 ku Energie.\n"..
"\n"..
"\n"..
"\n",
"Das Brechen\\, Mahlen und Siebe von Gestein dient zur Gewinnung von Erzen. Gesiebtes Kies kann aber auch anderweitig genutzt werden. Steinbrecher\\, Mühle und Sieb müssen angetrieben und damit in der Nähe einer Dampfmaschine aufgebaut werden.\n"..
"\n"..
"\n"..
"\n",
"Der Steinbrecher dient zum Abbau von Steinen und anderen Materialien aus dem Untergrund. Der Steinbrecher gräbt ein 5x5 Blöcke großes Loch. Die Tiefe ist einstellbar.\n"..
"Die Verarbeitungsleistung ist ein Block alle 4 s. Der Steinbrecher benötigt 10 ku Energie. Die maximale Tiefe beträgt 20 Meter. Für größere Tiefen siehe TA3/TA4.\n"..
"\n"..
"\n"..
"\n",
"Die Mühle ist in der Lage\\, verschiedenes Gestein\\, aber auch Holz und andere Items zu mahlen.\n"..
"Die Verarbeitungsleistung ist ein Item alle 4 s. Die Mühle benötigt 4 ku Energie.\n"..
"\n"..
"\n"..
"\n",
"Das Kiessieb ist in der Lage\\, Kies zu sieben um Erze zu gewinnen. Als Ergebnis erhält man teilweise \"gesiebtes Kies\"\\, was nicht wieder gesiebt werden kann.\n"..
"Die Verarbeitungsleistung ist ein Item alle 4 s. Das Kiessieb benötigt 3 ku Energie.\n"..
"\n"..
"\n"..
"\n",
"Mit TA2 Maschinen können nicht nur Erze gewonnen\\, sondern auch Gegenstände hergestellt werden.\n"..
"\n",
"Der Autocrafter dient zur automatischen Herstellung von Waren. Alles was der Spieler über das \"Crafting Grid\" herstellen kann\\, kann auch durch den Autocrafter erledigt werden. Dazu müssen im Menü des Autocrafters das Rezept eingegeben und die notwendigen Zutaten hinzugefügt werden.\n"..
"\n"..
"Zutaten und hergestellte Waren können über Röhren und Schieber in und aus dem Block transportiert werden.\n"..
"\n"..
"Die Verarbeitungsleistung ist ein Item alle 4 s. Der Autocrafter benötigt 4 ku Energie.\n"..
"\n"..
"\n"..
"\n",
"Die Elektronikfabrik ist eine Spezialmaschine und nur für die Herstellung der Vakuumröhren nutzbar. Vakuumröhren werden für TA3 Maschinen und Blöcke benötigt.\n"..
"\n"..
"Die Verarbeitungsleistung ist eine Vakuumröhre alle 6 s. Die Elektronikfabrik benötigt 8 ku Energie.\n"..
"\n"..
"\n"..
"\n",
"",
"Für manche Rezepte wird Wasser benötigt. Damit auch diese Rezepte automatisiert mit dem Autocrafter bearbeitet werden können\\, muss Wasser in Eimern bereitgestellt werden. Hierzu dient der Flüssigkeitensammler. Er benötigt leere Eimer und muss ins Wasser gestellt werden.\n"..
"\n"..
"Die Verarbeitungsleistung ist ein Wassereimer alle 8 s. Der Flüssigkeitensammler benötigt 3 ku Energie.\n"..
"\n"..
"\n"..
"\n",
"Die gesicherte Kiste kann nur von den Spielern genutzt werden\\, die an diesem Ort auch bauen können\\, also Protection Rechte besitzen. Es spielt dabei keine Rolle\\, wer die Kiste setzt. \n"..
"\n"..
"\n"..
"\n",
"Minetest teilt die Karte in sogenannte Map-Blocks ein. Das sind Würfel mit 16x16x16 Blöcke Kantenlänge. So ein Map-Block wird vom Server immer komplett geladen\\, aber es werden nur die Blöcke um einen Spieler herum geladen (ca. 2-3 Blöcke in alle Richtungen). In Sichtrichtung des Spielers sind es auch mehr Map-Blöcke. Nur dieser Teil der Welt ist aktiv und nur hier wachsen Pflanzen und Bäume bzw. laufen die Maschinen.\n"..
"\n"..
"Mit einem Forceload-Block kannst du erzwingen\\, dass der Map-Block\\, in dem der Forceload Block steht\\, immer geladen bleibt\\, solange du auf dem Server bist. Wenn alle deine Farmen und Maschinen mit Forceload Blöcken abgedeckt sind\\, ist immer alles am Laufen.\n"..
"\n"..
"Die Map-Blöcke mit ihren Koordinaten sind vordefiniert\\, also bspw. (0\\,0\\,0) bis (15\\,15\\,15)\\, oder (16\\,16\\,16) bis (31\\,31\\,31).\n"..
"Man kann einen Forceload-Block innerhalb eines Map-Blockes verschieben wie man will\\, die Position des Map-Blocks bleibt dabei unverändert. \n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta2",
"",
"ta2_firebox",
"ta2_boiler",
"ta2_cylinder",
"ta2_flywheel",
"ta2_steampipe",
"ta2_driveaxle",
"ta2_generator",
"",
"ta2_winch",
"ta2_weight_chest",
"techage:ta2_clutch_off",
"",
"tube",
"concentrator",
"ta2_pusher",
"ta2_distributor",
"",
"ta2_rinser",
"ta2_grinder",
"ta2_quarry",
"ta2_grinder",
"ta2_gravelsieve",
"",
"ta2_autocrafter",
"ta2_electronicfab",
"",
"ta2_liquidsampler",
"ta2_chest",
"ta2_forceload",
},
plans = {
"",
"steamengine",
"",
"",
"",
"",
"",
"",
"",
"ta2_storage",
"",
"",
"",
"itemtransport",
"",
"",
"",
"",
"gravelrinser",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

308
doc/manual_ta2_EN.lua Normal file
View File

@ -0,0 +1,308 @@
return {
titles = {
"1,TA2: Steam Age",
"2,Steam Engine",
"3,TA2 Firebox",
"3,TA2 Boiler",
"3,TA2 Cylinder",
"3,TA2 Flywheel",
"3,TA2 Steam Pipes",
"3,TA2 Drive Axle / TA2 Gearbox",
"3,TA2 Power Generator",
"2,TA2 energy storage",
"3,TA2 Winch",
"3,TA2 Weight Chest",
"3,TA2 Clutch",
"2,Push and sort items",
"3,TechAge Tube",
"3,Tube Concentrator",
"3,TA2 Pusher",
"3,TA2 Distributor",
"2,Gravel washer",
"3,TA2 Gravel Rinser",
"2,Dig stone\\, grind and sieve",
"3,TA2 Quarry",
"3,TA2 Grinder",
"3,TA2 Gravel Sieve",
"2,Produce Items",
"3,TA2 Autocrafter",
"3,TA2 Electronic Fab",
"2,Other blocks",
"3,TA2 Liquid Sampler",
"3,TA2 Protected Chest",
"3,Techage Forceload Block",
},
texts = {
"TA2 is about building and operating the first machines for processing ores. Some machines have to be driven via drive axles. To do this\\, you need to build a steam engine and heat it with coal or charcoal.\n"..
"\n"..
"In TA2 there is also a gravel rinser that can be used to wash out rare ores such as Usmium nuggets. You will need these nuggets later for further recipes.\n"..
"\n"..
"\n"..
"\n",
"The steam engine consists of several blocks and must be assembled as shown in the plan on the right. The blocks TA2 fire box\\, TA2 boiler top\\, TA2 boiler bottom\\, TA2 cylinder\\, TA2 flywheel and steam pipes are required.\n"..
"\n"..
"In addition\\, drive axles and gear blocks are required for changing direction. The flywheel must be connected to all machines that have to be driven via the drive axles.\n"..
"\n"..
"Always pay attention to the alignment of all blocks when placing:\n"..
"\n"..
" - Cylinder on the left\\, flywheel on the right\n"..
" - Connect steam pipes where there is a corresponding hole\n"..
" - Drive axle on flywheel only on the right\n"..
" - In all machines\\, the drive axles can be connected on all sides\\, which is not occupied by other functions\\, such as the IN and OUT holes in the grinder and sieve.\n"..
"\n"..
"The boiler must be filled with water. Fill up to 10 buckets of water in the boiler.\n"..
"The fire box must be filled with coal or charcoal.\n"..
"When the water is hot (temperature display at the top)\\, the steam engine can be started on the flywheel.\n"..
"\n"..
"The steam engine has a capacity of 25 ku\\, so it can drive several machines at the same time.\n"..
"\n"..
"\n"..
"\n",
"Part of the steam engine.\n"..
"\n"..
"The fire box must be filled with coal or charcoal. The burning time depends on the power demanded by the steam engine. Coal burns for 32 s and charcoal for 96 s under full load.\n"..
"\n"..
"\n"..
"\n",
"Part of the steam engine. Must be filled with water. This is done by clicking on the boiler with a water bucket. When there is no more water or the temperature drops too low\\, the steam engine switches off. With the steam engine\\, some water is lost as steam with each piston stroke\\, so water has to be refilled regularly.\n"..
"\n"..
"\n"..
"\n",
"Part of the steam engine.\n"..
"\n"..
"\n"..
"\n",
"Drive part of the steam engine. The flywheel must be connected to the machines via drive axles.\n"..
"\n"..
"\n"..
"\n",
"Part of the steam engine. The boiler must be connected to the cylinder via the steam pipes. The steam pipe has no branches\\, the maximum length is 12 m (blocks).\n"..
"\n"..
"\n"..
"\n",
"The drive axles are used to transmit power from the steam engine to other machines. The maximum length of a drive axis is 10 blocks. With TA2 Gearboxes\\, larger distances can be bridged\\, and branches and changes of direction can be realized.\n"..
"\n"..
"\n"..
"\n",
"The TA2 Power Generator is required to operate lamps or other power consumers on a steam engine. The TA2 Power Generator has to be connected to drive axles on one side and then supplies electricity on the other side.\n"..
"\n"..
"If the Power Generator is not supplied with sufficient power\\, it goes into an error state and must be reactivated with a right-click.\n"..
"\n"..
"The Power Generator takes max. 25 ku of axle power and provides on the other side max. 24 ku as electricity. So he consumes one ku for the conversion.\n"..
"\n"..
"\n"..
"\n",
"For larger systems with several steam engines or many driven machines\\, an energy storage system is recommended. The energy storage at TA2 works with position energy. For this purpose\\, ballast (stones\\, gravel\\, sand) is pulled up in a chest with the help of a cable winch. If there is excess energy in the axis network\\, the chest is pulled upwards. If more energy is required in the short term than the steam engine can supply\\, the energy store releases the stored energy again and the weight chest moves down again. \n"..
"The energy storage consists of several blocks and must be assembled as shown in the plan on the right. \n"..
"In order to achieve the maximum storage capacity\\, the chest must be completely filled with weights and the mast including the two gear boxes must be 12 blocks high. Smaller structures are also possible.\n"..
"\n"..
"\n"..
"\n",
"The cable winch must be connected to a gear box and can absorb excess energy and thus pull a weight chest upwards. \n"..
"When assembling the cable winch\\, make sure that the arrow on the top of the block points to the gearbox.\n"..
"The maximum rope length is 10 blocks. \n"..
"\n"..
"\n"..
"\n",
"This chest must be placed under the winch with a distance of up to 10 blocks and filled with cobblestone\\, gravel or sand. If the minimum weight of a stack (99+ items) is reached and there is excess energy\\, the box is automatically connected to the winch via a rope and pulled up. \n"..
"\n"..
"\n"..
"\n",
"With the clutch\\, axles and machines can be separated from the energy storage. This means that the axles after the clutch come to a standstill and machine systems can be rebuilt. When assembling the clutch\\, make sure that the arrow on the top of the block points to the energy storage system.\n"..
"\n"..
"\n"..
"\n",
"In order to transport objects from one processing station to the next\\, pushers and tubes are used. See plan.\n"..
"\n"..
"\n"..
"\n",
"Two machines can be connected with the help of a pusher and a tube. Tubes have no branches. The maximum length is 200 m (blocks).\n"..
"\n"..
"Alternatively\\, tubes can be placed using the Shift key. This allows\\, for example\\, tubes to be laid in parallel without them accidentally connecting.\n"..
"\n"..
"The transport capacity of a tube is unlimited and only limited by the pusher.\n"..
"\n"..
"\n"..
"\n",
"Several tubes can be combined into one tube via the concentrator. The direction in which all items are passed on is marked with an arrow. \n"..
"\n"..
"\n"..
"\n",
"A pusher is able to pull items out of boxes or machines and push them into other boxes or machines. In other words\\, there must be one and exactly one pusher between two blocks with inventory. Multiple pushers in a row are not possible.\n"..
"In the opposite direction\\, however\\, a pusher is permeable for items\\, so that a box can be filled via a tube and also taught.\n"..
"\n"..
"A pusher goes into the \"standby\" state if it has no items to push. If the output is blocked or the recipient's inventory is full\\, the pusher goes into the \"blocked\" state. The pusher automatically comes out of both states after a few seconds if the situation has changed.\n"..
"\n"..
"The processing power of a TA2 pusher is 2 items every 2 s.\n"..
"\n"..
"\n"..
"\n",
"The distributor is able to transport the items from his inventory sorted in up to four directions. To do this\\, the distributor must be configured accordingly.\n"..
"\n"..
"The distributor has a menu with 4 filters with different colors\\, corresponding to the 4 outputs. If an output is to be used\\, the corresponding filter must be activated via the \"on\" checkbox. All items that are configured for this filter are output via the assigned output. If a filter is activated without items being configured\\, we are talking about an \"unconfigured\"\\, open output.\n"..
"\n"..
"*Attention: The distributor is also a pusher at its output sides. Therefore\\, never pull items out of the distributor with a pusher!*\n"..
"\n"..
"There are two operating modes for a non-configured output:\n"..
"\n"..
"1) Output all items that cannot be output to any other exit\\, even if they are blocked.\n"..
"\n"..
"2) Only output the items that have not been configured for any other filter.\n"..
"\n"..
"In the first case\\, all items are always forwarded and the distributor does not run full. In the second case\\, items are held back and the distributor can run full and then block.\n"..
"\n"..
"The operating mode can be set using the \"blocking mode\" checkbox.\n"..
"\n"..
"The processing power of a TA2 distributor is 4 items every 2 s\\, whereby the distributor tries to distribute the 4 items to the open outputs.\n"..
"\n"..
"If the same item is configured multiple times in one filter\\, the long term distribution ratio will be influenced accordingly.\n"..
"\n"..
"Please note that the distribution is a probabilistic process. This means that the distribution rations won't be matched exactly\\, but only in the long term.\n"..
"\n"..
"The maximum stack size in the filters is 12\\; in total\\, not more than 36 items can be configured.\n"..
"\n"..
"\n"..
"\n",
"The gravel washer is a more complex machine with the goal of washing Usmium nuggets out of sieved gravel. A TA2 rinser with axis drive\\, a hopper\\, a chest and running water are required for the installation.\n"..
"\n"..
"Structure from left to right (see also plan):\n"..
"\n"..
" - A dirt block\\, on top of it the water source\\, surrounded on 3 sides by e.g. glass blocks\n"..
" - next to it the gravel rinser\\, if necessary with tube connections for the gravel delivery and removal\n"..
" - then the hopper with chest\n"..
"\n"..
"The whole thing is surrounded by further glass blocks\\, so that the water flows over the gravel rinser and the hopper and rinsed-out nuggets can be collected again by the hopper.\n"..
"\n"..
"\n"..
"\n",
"The gravel washer is able to rinse out the Usmium and copper ores from gravel that has already been sieved\\, provided that this is flushed with water.\n"..
"\n"..
"Whether the Gravel Rinser works correctly can be tested with sticks if these are placed in the inventory of the Gravel Rinser. These must be rinsed out individually and caught by the hopper.\n"..
"\n"..
"The processing power is one gravel item every 2 s. The gravel washer needs 3 ku of energy.\n"..
"\n"..
"\n"..
"\n",
"Crushing\\, grinding and sieving of cobblestone is used to extract ores. Sieved gravel can also be used for other purposes. Quarry\\, grinder and sieve must be driven and thus installed near a steam engine.\n"..
"\n"..
"\n"..
"\n",
"The quarry is used to remove stones and other materials from the underground. The quarry digs a 5x5 block hole. The depth is adjustable.\n"..
"The processing power is one block every 4 s. The quarry needs 10 ku of energy. The maximum depth is 20 meters. For greater depths see TA3 / TA4.\n"..
"\n"..
"\n"..
"\n",
"The grinder is able to grind various rocks\\, but also wood and other items.\n"..
"The processing power is one item every 4 s. The grinder needs 4 ku of energy.\n"..
"\n"..
"\n"..
"\n",
"The gravel sieve is able to sieve gravel to extract ores. The result is partially \"sieved gravel\"\\, which cannot be sieved again.\n"..
"The processing power is one item every 4 s. The gravel sieve requires 3 ku of energy.\n"..
"\n"..
"\n"..
"\n",
"TA2 machines can not only extract ores\\, but also produce objects.\n"..
"\n",
"The autocrafter is used for the automatic production of goods. Everything that the player can produce via the \"Crafting Grid\" can also be done by the autocrafter. To do this\\, the recipe must be entered in the menu of the autocrafter and the necessary ingredients added.\n"..
"\n"..
"Ingredients and manufactured goods can be transported in and out of the block via tubes and pushers.\n"..
"\n"..
"The processing power is one item every 4 s. The autocrafter requires 4 ku of energy.\n"..
"\n"..
"\n"..
"\n",
"The electronic fab is a special machine and can only be used for the production of vacuum tubes. Vacuum tubes are required for TA3 machines and blocks.\n"..
"\n"..
"The processing power is one vacuum tube every 6 s. The electronic fab requires 8 ku of energy.\n"..
"\n"..
"\n"..
"\n",
"",
"Some recipes require water. So that these recipes can also be processed automatically with the autocrafter\\, water must be provided in buckets. The liquid sampler is used for this. He needs empty buckets and has to be put in the water.\n"..
"\n"..
"The processing capacity is one water bucket every 8 s. The liquid sampler requires 3 ku of energy.\n"..
"\n"..
"\n"..
"\n",
"The protected chest can only be used by players who can build at this location\\, i.e. who have protection rights. It does not matter who sets the chest.\n"..
"\n"..
"\n"..
"\n",
"Minetest divides the map into so-called map blocks. These are cubes with an edge length of 16x16x16 blocks. Such a map block is always loaded completely by the server\\, but only the blocks around a player are loaded (approx. 2-3 blocks in all directions). In the player's direction of view\\, there are also more map blocks. Only this part of the world is active and only here do plants and trees grow or the machines run.\n"..
"\n"..
"With a forceload block you can force the map block in which the forceload block is located to remain loaded as long as you are on the server. When all your farms and machines are covered with Forceload blocks\\, everything is always running.\n"..
"\n"..
"The map blocks with their coordinates are predefined\\, e.g. (0\\,0\\,0) to (15\\,15\\,15)\\, or (16\\,16\\,16) to (31\\,31\\,31).\n"..
"You can move a forceload block within a map block as you like\\, the position of the map block remains unchanged.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta2",
"",
"ta2_firebox",
"ta2_boiler",
"ta2_cylinder",
"ta2_flywheel",
"ta2_steampipe",
"ta2_driveaxle",
"ta2_generator",
"",
"ta2_winch",
"ta2_weight_chest",
"techage:ta2_clutch_off",
"",
"tube",
"concentrator",
"ta2_pusher",
"ta2_distributor",
"",
"ta2_rinser",
"ta2_grinder",
"ta2_quarry",
"ta2_grinder",
"ta2_gravelsieve",
"",
"ta2_autocrafter",
"ta2_electronicfab",
"",
"ta2_liquidsampler",
"ta2_chest",
"ta2_forceload",
},
plans = {
"",
"steamengine",
"",
"",
"",
"",
"",
"",
"",
"ta2_storage",
"",
"",
"",
"itemtransport",
"",
"",
"",
"",
"gravelrinser",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

306
doc/manual_ta2_pt-BR.lua Normal file
View File

@ -0,0 +1,306 @@
return {
titles = {
"1,TA2: Era a Vapor",
"2,Máquina a Vapor",
"3,Caixa de Fogo(Firebox) TA2",
"3,TA2 Caldeira(Boiler)",
"3,TA2 Cilindro(Cylinder)",
"3,TA2 Volante(Flywheel)",
"3,TA2 Tubos de Vapor(Steam pipes)",
"3,TA2 Eixo de Transmissão(Drive axle) TA2 / Caixa de Engrenagem(Gearbox)",
"3,TA2 Gerador de Energia",
"2,TA2 Armazenamento de Energia",
"3,TA2 Guincho",
"3,TA2 Baú de Pesos",
"3,TA2 Embreagem",
"2,Empurrar e classificar itens",
"3,Tubo TechAge",
"3,Tubo Concentrador",
"3,TA2 Pusher",
"3,TA2 Distributor(Distribuidor)",
"2,Gravel washer(Lavador de cascalho)",
"3,TA2 Gravel Rinser(Enxaguatório de cascalho)",
"2,Escavar pedra\\, moer e peneirar",
"3,TA2 Quarry(Pedreira)",
"3,TA2 Grinder(Moedor)",
"3,TA2 Gravel Sieve(Peneira de cascalho)",
"2,Produzindo Itens",
"3,TA2 Autocrafter",
"3,TA2 Electronic Fab",
"2,Outros Blocos",
"3,TA2 Liquid Sampler",
"3,TA2 Protected Chest",
"3,Techage Forceload Block",
},
texts = {
"TA2 trata-se de construir e operar as primeiras máquinas para processamento de minérios. Algumas máquinas precisam ser acionadas por eixos de transmissão. Para fazer isso\\, você precisa construir uma máquina a vapor e aquecê-la com carvão ou carvão vegetal.\n"..
"\n"..
"No TA2\\, há também um lavador de cascalho que pode ser usado para lavar minérios raros\\, como pepitas de Usmium. Você precisará dessas pepitas posteriormente para receitas adicionais.\n"..
"\n"..
"\n"..
"\n",
"A máquina a vapor é composta por vários blocos e deve ser montada conforme mostrado no plano à direita. São necessários os blocos da Caixa de Fogo(Firebox) TA2\\, parte superior da Caldeira(Boiler) TA2\\, parte inferior da Caldeira(Boiler) TA2\\, Cilindro(Cylinder) TA2\\, Volante(Flywheel) TA2 e Tubos de Vapor(steam piper) TA2.\n"..
"\n"..
"Além disso\\, são necessários Eixos de Transmissão(drive axles) e blocos de Engrenagem(gear) para mudança de direção. O Volante deve ser conectado a todas as máquinas que precisam ser acionadas pelos Eixos de Transmissão.\n"..
"\n"..
"Sempre preste atenção ao alinhamento de todos os blocos ao colocá-los:\n"..
"\n"..
" - Cilindro à esquerda\\, volante à direita\n"..
" - Conectar os tubos de vapor onde há um furo correspondente\n"..
" - Eixo de transmissão no volante apenas à direita\n"..
" - Em todas as máquinas\\, os eixos de transmissão podem ser conectados em todos os lados que não estejam ocupados por outras funções\\, como os furos de ENTRADA(IN) e SAÍDA(OUTPUT) no Moedor(grinder) e na Peneira(sieve).\n"..
"\n"..
"A Caldeira deve ser preenchida com água. Preencha até 10 baldes de água na caldeira.\n"..
"A Caixa de fogo deve ser preenchida com carvão ou carvão vegetal.\n"..
"Quando a água estiver quente (indicador de temperatura no topo)\\, a máquina a vapor pode ser iniciada no Volante.\n"..
"\n"..
"A máquina a vapor tem uma capacidade de 25ku\\, podendo acionar várias máquinas ao mesmo tempo.\n"..
"\n"..
"\n"..
"\n",
"Parte da máquina a vapor.\n"..
"\n"..
"A Caixa de fogo deve ser preenchida com carvão ou carvão vegetal. O tempo de queima depende da potência exigida pela máquina a vapor. O carvão queima por 32s e o carvão vegetal por 96s em carga máxima.\n"..
"\n"..
"\n"..
"\n",
"Parte da máquina a vapor. Deve ser preenchida com água. Isso é feito clicando na caldeira com um balde de água. Quando não há mais água ou a temperatura cai muito\\, a máquina a vapor desliga. Com a máquina a vapor\\, parte da água é perdida como vapor a cada curso do pistão\\, então a água deve ser reabastecida regularmente.\n"..
"\n"..
"\n"..
"\n",
"Parte da máquina a vapor.\n"..
"\n"..
"\n"..
"\n",
"Parte motora da máquina a vapor. O Volante deve ser conectado às máquinas por meio de eixos de transmissão.\n"..
"\n"..
"\n"..
"\n",
"Parte da máquina a vapor. A caldeira deve ser conectada ao cilindro por meio dos Tubos de vapor. O tubo de vapor não tem ramificações\\, o comprimento máximo é 12 m (blocos).\n"..
"\n"..
"\n"..
"\n",
"Os Eixos de transmissão são usados para transmitir energia da máquina a vapor para outras máquinas. O comprimento máximo de um eixo de transmissão é 10 blocos. Com as Caixas de Engrenagem TA2\\, é possível vencer distâncias maiores\\, e também realizar ramificações e mudanças de direção.\n"..
"\n"..
"\n"..
"\n",
"O Gerador de Energia TA2 é necessário para operar lâmpadas ou outros consumidores de energia em uma Máquina a vapor. O Gerador de Energia TA2 deve ser conectado aos eixos de transmissão de um lado e\\, em seguida\\, fornece eletricidade do outro lado.\n"..
"\n"..
"Se o Gerador de Energia não receber energia suficiente\\, ele entra em estado de erro e deve ser reativado com um clique direito.\n"..
"\n"..
"O Gerador de Energia consome no máximo 25ku de potência do eixo e fornece no máximo 24ku como eletricidade do outro lado. Portanto\\, ele consome um ku para a conversão.\n"..
"\n"..
"\n"..
"\n",
"Para sistemas maiores com várias máquinas a vapor ou muitas máquinas acionadas\\, é recomendado um sistema de armazenamento de energia. O armazenamento de energia no TA2 funciona com energia potencial. Para isso\\, o peso (pedras\\, cascalho\\, areia) é puxado para cima em um baú com a ajuda de um guincho. Se houver excesso de energia na rede de eixos\\, o baú é puxado para cima. Se mais energia for necessária a curto prazo do que a máquina a vapor pode fornecer\\, o armazenamento de energia libera a energia armazenada novamente e o baú de pesos desce novamente.\n"..
"O armazenamento de energia é composto por vários blocos e deve ser montado conforme mostrado no plano à direita. \n"..
"Para alcançar a capacidade máxima de armazenamento\\, o baú deve ser completamente preenchido com pesos e o mastro\\, incluindo as duas caixas de engrenagens\\, deve ter 12 blocos de altura. Estruturas menores também são possíveis.\n"..
"\n"..
"\n"..
"\n",
"O guincho deve ser conectado a uma caixa de engrenagens e pode absorver energia excessiva e assim puxar um baú de pesos para cima. \n"..
"Ao montar o guincho\\, certifique-se de que a seta no topo do bloco aponte para a caixa de engrenagens.\n"..
"O comprimento máximo da corda é 10 blocos. \n"..
"\n"..
"\n"..
"\n",
"Este baú deve ser colocado sob o guincho com uma distância de até 10 blocos e preenchido com pedras\\, cascalho ou areia. Se o peso mínimo de uma pilha (99+ itens)\n"..
"\n",
"Com a embreagem\\, eixos e máquinas podem ser separados do armazenamento de energia. Isso significa que os eixos após a embreagem param e sistemas de máquinas podem ser reconstruídos. Ao montar a embreagem\\, certifique-se de que a seta na parte superior do bloco aponta para o sistema de armazenamento de energia.\n"..
"\n"..
"\n"..
"\n",
"Para transportar objetos de uma estação de processamento para a próxima\\, são usados pushers e tubos. Veja o plano.\n"..
"\n"..
"\n"..
"\n",
"Duas máquinas podem ser conectadas com a ajuda de um pusher e um tubo. Tubos não têm ramificações. O comprimento máximo é 200m (blocos).\n"..
"\n"..
"Alternativamente\\, os tubos podem ser colocados usando a tecla Shift. Isso permite\\, por exemplo\\, que tubos sejam colocados em paralelo sem que eles se conectem acidentalmente.\n"..
"\n"..
"A capacidade de transporte de um tubo é ilimitada e é limitada apenas pelo pusher.\n"..
"\n"..
"\n"..
"\n",
"Vários tubos podem ser combinados em um único tubo via concentrador. A direção na qual todos os itens são passados é marcada com uma seta. \n"..
"\n"..
"\n"..
"\n",
"Um pusher(empurrador) é capaz de puxar itens de caixas ou máquinas e empurrá-los para outras caixas ou máquinas. Em outras palavras\\, deve haver um e apenas um pusher entre dois blocos com inventário. Múltiplos pushers em sequência não são possíveis.\n"..
"No entanto\\, na direção oposta\\, um pusher é permeável a itens\\, de modo que uma caixa pode ser preenchida via tubo e também ensinada.\n"..
"\n"..
"Um pusher entra no estado \"standby\" se não tiver itens para empurrar. Se a saída estiver bloqueada ou o inventário do destinatário estiver cheio\\, o pusher entra no estado \"bloqueado\". O pusher automaticamente sai de ambos os estados após alguns segundos se a situação mudar.\n"..
"\n"..
"A capacidade de processamento de um pusher TA2 é de 2 itens a cada 2 s.\n"..
"\n"..
"\n"..
"\n",
"O distribuidor é capaz de transportar os itens de seu inventário ordenados em até quatro direções. Para fazer isso\\, o distribuidor deve ser configurado conforme necessário.\n"..
"\n"..
"O distribuidor possui um menu com 4 filtros com cores diferentes\\, correspondendo às 4 saídas. Se uma saída for usada\\, o filtro correspondente deve ser ativado via caixa de seleção \"ligado\". Todos os itens configurados para este filtro são enviados através da saída designada. Se um filtro for ativado sem que itens sejam configurados\\, estamos falando de uma saída \"não configurada\"\\, aberta.\n"..
"\n"..
"*Atenção: O distribuidor também é um pusher em suas saídas. Portanto\\, nunca puxe itens do distribuidor com um pusher!*\n"..
"\n"..
"Existem dois modos de operação para uma saída não configurada:\n"..
"\n"..
"1) Enviar todos os itens que não podem ser enviados para nenhuma outra saída\\, mesmo que estejam bloqueados.\n"..
"\n"..
"2) Enviar apenas os itens que não foram configurados para nenhum outro filtro.\n"..
"\n"..
"No primeiro caso\\, todos os itens são sempre encaminhados e o distribuidor não fica cheio. No segundo caso\\, os itens são retidos e o distribuidor pode ficar cheio e\\, em seguida\\, bloquear.\n"..
"\n"..
"O modo de operação pode ser definido usando a caixa de seleção \"modo de bloqueio\".\n"..
"\n"..
"A capacidade de processamento de um distribuidor TA2 é de 4 itens a cada 2s\\, onde o distribuidor tenta distribuir os 4 itens para as saídas abertas.\n"..
"\n"..
"Se o mesmo item for configurado várias vezes em um filtro\\, a proporção de distribuição a longo prazo será influenciada de acordo.\n"..
"\n"..
"Observe que a distribuição é um processo probabilístico. Isso significa que as proporções de distribuição não serão correspondidas exatamente\\, mas apenas a longo prazo.\n"..
"\n"..
"O tamanho máximo de pilha nos filtros é 12\\; no total\\, não mais que 36 itens podem ser configurados.\n"..
"\n"..
"\n"..
"\n",
"O lavador de cascalho é uma máquina mais complexa com o objetivo de lavar pepitas de Usmium a partir de cascalho peneirado. Um enxaguatório TA2 com eixo de acionamento\\, um funil\\, um baú e água corrente são necessários para a instalação.\n"..
"\n"..
"Estrutura da esquerda para a direita (veja também o plano):\n"..
"\n"..
" - Um bloco de terra\\, sobre ele a fonte de água\\, cercada em 3 lados\\, por exemplo\\, por blocos de vidro\n"..
" - Ao lado\\, o enxaguatório de cascalho\\, se necessário com conexões de tubulação para a entrega e remoção de cascalho\n"..
" - Em seguida\\, o funil com baú\n"..
"\n"..
"O conjunto é cercado por mais blocos de vidro\\, para que a água flua sobre o enxaguatório de cascalho e o funil\\, e as pepitas lavadas possam ser coletadas novamente pelo funil.\n"..
"\n"..
"\n"..
"\n",
"O lavador de cascalho é capaz de enxaguar os minérios de Usmium e cobre do cascalho que já foi peneirado\\, desde que seja lavado com água.\n"..
"\n"..
"Se o Enxaguatório de Cascalho funciona corretamente\\, pode ser testado com pedaços de madeira\\, se estes forem colocados no inventário do Enxaguatório de Cascalho. Eles devem ser enxaguados individualmente e recolhidos pelo funil.\n"..
"\n"..
"A capacidade de processamento é de um item de cascalho a cada 2s. O lavador de cascalho precisa de 3 ku de energia.\n"..
"\n"..
"\n"..
"\n",
"Esmagar\\, moer e peneirar pedregulhos é usado para extrair minérios. O cascalho peneirado também pode ser usado para outros fins. A pedreira\\, moedor e peneira devem ser acionados e\\, portanto\\, instalados perto de uma máquina a vapor.\n"..
"\n"..
"\n"..
"\n",
"A pedreira é usada para remover pedras e outros materiais do subsolo. A pedreira escava um buraco de 5x5 blocos. A profundidade é ajustável.\n"..
"A capacidade de processamento é de um bloco a cada 4s. A pedreira precisa de 10 ku de energia. A profundidade máxima é de 20 metros. Para maiores profundidades\\, consulte TA3 / TA4.\n"..
"\n"..
"\n"..
"\n",
"O moedor é capaz de moer várias rochas\\, mas também madeira e outros itens.\n"..
"A capacidade de processamento é de um item a cada 4s. O moedor precisa de 4 ku de energia.\n"..
"\n"..
"\n"..
"\n",
"A peneira de cascalho é capaz de peneirar cascalho para extrair minérios. O resultado é parcialmente \"sieved gravel\"\\, que não pode ser peneirado novamente.\n"..
"A capacidade de processamento é de um item a cada 4s. A peneira de cascalho requer 3 ku de energia.\n"..
"\n"..
"\n"..
"\n",
"As máquinas TA2 podem não apenas extrair minérios\\, mas também produzir objetos.\n"..
"\n",
"O autocrafter é usado para a produção automática de bens. Tudo o que o jogador pode produzir via \"Crafting Grid\" também pode ser feito pelo autocrafter. Para isso\\, a receita deve ser inserida no menu do autocrafter e os ingredientes necessários adicionados.\n"..
"\n"..
"Ingredientes e produtos fabricados podem ser transportados para dentro e para fora do bloco por meio de tubos e pushers.\n"..
"\n"..
"A capacidade de processamento é de um item a cada 4s. O autocrafter requer 4 ku de energia.\n"..
"\n"..
"\n"..
"\n",
"O electronic fab é uma máquina especial e só pode ser usada para a produção de tubos de vácuo. Tubos de vácuo são necessários para máquinas e blocos TA3.\n"..
"\n"..
"A capacidade de processamento é de um tubo de vácuo a cada 6s. O electronic fab requer 8 ku de energia.\n"..
"\n"..
"\n"..
"\n",
"",
"Algumas receitas requerem água. Para que essas receitas também possam ser processadas automaticamente com o autocrafter\\, água deve ser fornecida em baldes. Isso é feito usando o liquid sampler. Ele precisa de baldes vazios e deve ser colocado na água.\n"..
"\n"..
"A capacidade de processamento é de um balde de água a cada 8s. O liquid sampler requer 3 ku de energia.\n"..
"\n"..
"\n"..
"\n",
"O protected chest só pode ser usado por jogadores que têm permissão de construção neste local\\, ou seja\\, que têm direitos de proteção. Não importa quem coloca o baú.\n"..
"\n"..
"\n"..
"\n",
"O Minetest divide o mapa em chamados map blocks. Estes são cubos com uma aresta de 16x16x16 blocos. Um map block é sempre completamente carregado pelo servidor\\, mas apenas os blocos ao redor de um jogador são carregados (aproximadamente 2-3 blocos em todas as direções). Na direção de visão do jogador\\, também existem mais map blocks. Apenas esta parte do mundo é ativa e apenas aqui as plantas e árvores crescem ou as máquinas funcionam.\n"..
"\n"..
"Com um bloco forceload\\, você pode forçar o map block em que o bloco forceload está localizado a permanecer carregado enquanto você estiver no servidor. Quando todos os seus campos e máquinas estão cobertos com blocos Forceload\\, tudo está sempre em execução.\n"..
"\n"..
"Os map blocks com suas coordenadas são predefinidos\\, por exemplo\\, (0\\,0\\,0) a (15\\,15\\,15)\\, ou (16\\,16\\,16) a (31\\,31\\,31).\n"..
"Você pode mover um bloco forceload dentro de um map block como quiser\\, a posição do map block permanece inalterada.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta2",
"",
"ta2_firebox",
"ta2_boiler",
"ta2_cylinder",
"ta2_flywheel",
"ta2_steampipe",
"ta2_driveaxle",
"ta2_generator",
"",
"ta2_winch",
"",
"techage:ta2_clutch_off",
"",
"tube",
"concentrador",
"ta2_pusher",
"ta2_distributor",
"",
"ta2_rinser",
"ta2_grinder",
"ta2_quarry",
"ta2_grinder",
"ta2_gravelsieve",
"",
"ta2_autocrafter",
"ta2_electronicfab",
"",
"ta2_liquidsampler",
"ta2_chest",
"ta2_forceload",
},
plans = {
"",
"steamengine",
"",
"",
"",
"",
"",
"",
"",
"ta2_storage",
"",
"",
"",
"itemtransport",
"",
"",
"",
"",
"gravelrinser",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

934
doc/manual_ta3_DE.lua Normal file
View File

@ -0,0 +1,934 @@
return {
titles = {
"1,TA3: Ölzeitalter",
"2,Kohlekraftwerk / Ölkraftwerk",
"3,TA3 Kraftwerks-Feuerbox / Power Station Firebox",
"3,TA3 Kraftwerks-Ölbrenner / TA3 Power Station Oil Burner",
"3,TA3 Boiler unten/oben",
"3,TA3 Turbine",
"3,TA3 Generator",
"3,TA3 Kühler / Cooler",
"2,Elektrischer Strom",
"3,Bedeutung von Speichersystemen",
"3,TA Stromkabel / Electric Cable",
"3,TA Verteilerdose / Electric Junction Box",
"3,TA Stromleitung / Power Line",
"3,TA Strommast / Power Pole",
"3,TA Strommastkopf / Power Pole Top",
"3,TA Strommastkopf 2 / Power Pole Top 2",
"3,TA Stromschalter / Power Switch",
"3,TA Stromschalter klein / Power Switch Small",
"3,TA Stromschalterbox / Power Switch Box",
"3,TA3 Kleiner Stromgenerator / Tiny Power Generator",
"3,TA3 Akku Block / TA3 Accu Box",
"3,TA3 Strom Terminal / Power Terminal",
"3,TA3 Elektromotor / TA3 Electric Motor",
"2,TA3 Industrieofen",
"3,TA3 Ofen-Ölbrenner / Furnace Oil Burner",
"3,TA3 Ofenoberteil / Furnace Top",
"3,TA3 Gebläse / Booster",
"2,Flüssigkeiten",
"3,TA3 Tank / TA3 Tank",
"3,TA3 Pumpe / TA3 Pump",
"3,TA Einfülltrichter / TA Liquid Filler",
"3,TA4 Röhre / Pipe",
"3,TA3 Rohr/Wanddurchbruch / TA3 Pipe Wall Entry Blöcke",
"3,TA Ventil / TA Valve",
"2,Öl-Förderung",
"3,TA3 Ölexplorer / Oil Explorer",
"3,TA3 Ölbohrkiste / Oil Drill Box",
"3,TA3 Ölpumpe / Oil Pumpjack",
"3,TA3 Bohrgestänge / Drill Pipe",
"3,Öltank / Oil Tank",
"2,Öl-Transport",
"3,Öl-Transport mit dem Tankwagen",
"3,Öl-Transport mit Fässern über Minecarts",
"3,Tankwagen / Tank Cart",
"3,Kistenwagen / Chest Cart",
"2,Öl-Verarbeitung",
"3,Destillationsturm / distiller tower",
"4,Aufkocher / reboiler)",
"2,Logik-/Schalt-Blöcke",
"3,TA3 Taster/Schalter / Button/Switch",
"3,TA3 Kommando Konverter / Command Converter",
"3,TA3 Flipflop / Flip-Flop",
"3,TA3 Logikblock / Logic Block",
"3,TA3 Wiederholer / Repeater",
"3,TA3 Sequenzer / Sequencer",
"3,TA3 Timer",
"3,TA3 Terminal",
"3,TechAge Farblampe / Color Lamp",
"3,Tür/Tor Blöcke / Door/Gate Blocks",
"3,TA3 Tür Controller / Door Controller",
"3,TA3 Tür Controller II / Door Controller II",
"3,TA3 Sound Block",
"3,TA3 Mesecons Umsetzer / TA3 Mesecons Converter",
"2,Detektoren",
"3,TA3 Detektor / Detector",
"3,TA3 Wagen Detektor / Cart Detector",
"3,TA3 Block Detektor / Node Detector",
"3,TA3 Spieler Detektor / Player Detector",
"3,TA3 Lichtdetektor",
"2,TA3 Maschinen",
"3,TA3 Schieber / Pusher",
"3,TA3 Verteiler / Distributor",
"3,TA3 Autocrafter",
"3,TA3 Elektronikfabrik / Electronic Fab",
"3,TA3 Steinbrecher / Quarry",
"3,TA3 Kiessieb / Gravel Sieve",
"3,TA3 Kieswaschanlage / Gravel Rinser",
"3,TA3 Mühle / Grinder",
"3,TA3 Injektor / Injector",
"2,Werkzeuge",
"3,Techage Info Tool",
"3,TechAge Programmer",
"3,TechAge Kelle / Trowel",
"3,TA3 Bohrgestängezange / TA3 Drill Pipe Wrench",
"3,Techage Schraubendreher / Screwdriver",
"3,TechAge Montagewerkzeug / Assembly Tool",
},
texts = {
"Bei TA3 gilt es\\, die Dampf-betriebenen Maschinen durch leistungsfähigere und mit elektrischem Strom betriebene Maschinen abzulösen.\n"..
"\n"..
"Dazu musst du Kohlekraftwerke und Generatoren bauen. Bald wirst du sehen\\, dass dein Strombedarf nur mit Öl-betriebenen Kraftwerken zu decken ist. Also machst du dich auf die Suche nach Erdöl. Bohrtürme und Ölpumpen helfen die\\, an das Öl zu kommen. Schienenwege dienen dir zum Öltransport bis in die Kraftwerke.\n"..
"\n"..
"Das Industrielle Zeitalter ist auf seinem Höhepunkt.\n"..
"\n"..
"\n"..
"\n",
"Das Kohlekraftwerk besteht aus mehreren Blöcken und muss wie im Plan rechts abgebildet\\, zusammen gebaut werden. Dazu werden die Blöcke TA3 Kraftwerks-Feuerbox\\, TA3 Boiler oben\\, TA3 Boiler unten\\, TA3 Turbine\\, TA3 Generator und TA3 Kühler benötigt.\n"..
"\n"..
"Der Boiler muss mit Wasser gefüllt werden. Dazu bis zu 10 Eimer Wasser in den Boiler füllen.\n"..
"Die Feuerbox muss mit Kohle oder Holzkohle gefüllt werden.\n"..
"Wenn das Wasser heiß ist\\, kann der Generator gestartet werden.\n"..
"\n"..
"Das Kraftwerk kann alternativ auch mit einem Ölbrenner ausgestattet und dann mit Öl betrieben werden.\n"..
"Das Öl kann über eine Pumpe und Ölleitung nachgefüllt werden.\n"..
"\n"..
"Das Kraftwerk liefert eine Leistung von 80 ku.\n"..
"\n"..
"\n"..
"\n",
"Teil des Kraftwerks. \n"..
"Die Feuerbox muss mit Kohle oder Holzkohle gefüllt werden. Die Brenndauer ist abhängig von der Leistung\\, die vom Kraftwerk angefordert wird. Unter Volllast brennt Kohle 20 s und Holzkohle 60 s. Unter Teillast entsprechend länger (50% Last = doppelte Zeit).\n"..
"\n"..
"\n"..
"\n",
"Teil des Kraftwerks. \n"..
"\n"..
"Der Ölbrenner kann mit Erdöl\\, Schweröl\\, Naphtha oder Benzin gefüllt werden. Die Brenndauer ist abhängig von der Leistung\\, die vom Kraftwerk angefordert wird. Unter Volllast brennt Erdöl 15 s\\, Schweröl 20 s\\, Naphtha 22 s und Benzin 25 s. \n"..
"\n"..
"Unter Teillast entsprechend länger (50% Last = doppelte Zeit).\n"..
"\n"..
"Der Ölbrenner kann nur 50 Einheiten Kraftstoff aufnehmen. Ein zusätzlicher Öltank und eine Ölpumpe sind daher ratsam.\n"..
"\n"..
"\n"..
"\n",
"Teil des Kraftwerk. Muss mit Wasser gefüllt werden. Wem kein Wasser mehr vorhanden ist oder die Temperatur zu weit absinkt\\, schaltet sich das Kraftwerk ab. Der Wasserverbrauch des TA3-Kessels ist durch den geschlossenen Dampfkreislauf viel geringer als bei der Dampfmachine.\n"..
"Bei der Dampfmaschine geht bei jedem Kolbenhub etwas Wasser als Dampf verloren.\n"..
"\n"..
"\n"..
"\n",
"Die Turbine ist Teil des Kraftwerk. Sie muss neben den Generator gesetzt und über Dampfleitungen mit dem Boiler und dem Kühler\\, wie im Plan abgebildet\\, verbunden werden.\n"..
"\n"..
"\n"..
"\n",
"Der Generator dient zur Stromerzeugung. Er muss über Stromkabel und Verteilerdosen mit den Maschinen verbunden werden.\n"..
"\n"..
"\n"..
"\n",
"Dient zur Abkühlung des heißen Dampfs aus der Turbine. Muss über Dampfleitungen mit dem Boiler und der Turbine\\, wie im Plan abgebildet\\, verbunden werden.\n"..
"\n"..
"\n"..
"\n",
"In TA3 (und TA4) werden die Maschinen mit Strom angetrieben. Dazu müssen die Maschinen\\, Speichersysteme und Generatoren mit Stromkabel verbunden werden.\n"..
"TA3 besitzt 2 Arten von Stromkabel:\n"..
"\n"..
" - Isolierte Kabel (TA Stromkabel) für die lokale Verkabelung im Boden oder in Gebäuden. Diese Kabel lassen sich in der Wand oder im Boden verstecken (können mit der Kelle \"verputzt\" werden).\n"..
" - Überlandleitungen (TA Stromleitung) für Freiluftverkabelung über große Strecken. Diese Kabel sind geschützt\\, können also von anderen Spielern nicht entfernt werden.\n"..
"\n"..
"Mehrere Verbraucher\\, Speichersysteme und Generatoren können in einem Stromnetzwerk zusammen betrieben werden. Mit Hilfe der Verteilerdosen können so Netzwerke aufgebaut werden.\n"..
"Wird zu wenig Strom bereitgestellt\\, gehen die Verbraucher aus.\n"..
"In diesem Zusammenhang ist auch wichtig\\, dass die Funktionsweise von Forceload Blöcken verstanden wurde\\, denn bspw. Generatoren liefern nur Strom\\, wenn der entsprechende Map-Block geladen ist. Dies kann mit einen Forceload Block erzwungen werden.\n"..
"\n"..
"In TA4 kommt noch ein Kabel für die Solaranlage hinzu.\n"..
"\n"..
"\n"..
"\n",
"Speichersysteme im Stromnetz erfüllen zwei Aufgaben:\n"..
"\n"..
" - Um Bedarfsspitzen abzufangen: Alle Generatoren liefern immer gerade soviel Leistung\\, wie benötigt wird. Werden aber Verbraucher ein/ausgeschaltet oder kommt es aus anderen Gründen zu Bedarfsschwankungen\\, so können Verbraucher kurzzeitig ausfallen. Um dies zu verhindern\\, sollte immer mindestens ein Akkublock in jedem Netzwerk vorhanden sein. Dieser dient als Puffer und gleicht diese Schwankungen im Sekundenbereich aus.\n"..
" - Um regenerative Energie zu speichern: Solar und Wind stehen nicht 24 Stunden am Tag zur Verfügung. Damit die Stromversorgung nicht ausfällt\\, wenn kein Strom produziert wird\\, müssen ein oder mehrere Speichersysteme im Netzwerk verbaut werden. Alternativ können die Lücken auch mit Öl/Kohle-Strom überbrückt werden.\n"..
"\n"..
"Ein Speichersystem gibt seine Kapazität in kud an\\, also ku pro day (Tag). Bspw. ein Speichersystem mit 100 kud liefert 100 ku einen Spieltag lang\\, oder auch 10 ku für 10 Spieltage.\n"..
"\n"..
"Alle TA3/TA4 Energiequellen besitzen eine einstellbare Ladecharakteristik. Standardmäßig ist diese auf \"80% - 100%\" eingestellt. Dies bedeutet\\, dass die Leistung ab 80% Füllung des Speichersystems immer weiter reduziert wird\\, bis sie bei 100 % komplett abschaltet. Sofern Strom im Netzwerk benötigt wird\\, werden die 100 % nie erreicht\\, da die Leistung des Generators irgendwann auf den Strombedarf im Netzwerk abgesunken ist und damit das Speichersystem nicht mehr geladen\\, sondern nur noch die Verbraucher bedient werden.\n"..
"\n"..
"Dies hat mehrere Vorteile:\n"..
"\n"..
" - Die Ladecharakteristik ist einstellbar. Damit kann man bspw. Öl/Kohle Energiequellen bei 60% und die regenerativen Energiequellen erst bei 80% zurückfahren. Damit wird nur Öl/Kohle verbrannt\\, wenn nicht ausreichend regenerativen Energiequellen zur Verfügung stehen.\n"..
" - Mehrere Energiequellen können parallel betrieben werden und werden dabei nahezu gleichmäßig belastet\\, denn alle Energiequellen arbeiten bspw. bis 80% Ladekapazität des Speichersystems mit ihrer vollen Leistung und fahren dann gleichzeitig ihre Leistung zurück.\n"..
" - Alle Speichersysteme in einem Netzwerk bilden einen großen Puffer. An jedem Speichersystem aber auch am Strom Terminal kann immer die Ladekapazität und der Füllungsgrad des gesamten Speichersystems in Prozent abgelesen werden.\n"..
"\n"..
"\n"..
"\n",
"Für die lokale Verkabelung im Boden oder in Gebäuden.\n"..
"Abzweigungen können mit Hilfe von Verteilerdosen realisiert werden. Die maximale Kabellänge zwischen Maschinen oder Verteilerdosen beträgt 1000 m. Es können maximale 1000 Knoten in einem Strom-Netzwerk verbunden werden. Als Knoten zählen alle Blöcke mit Stromanschluss\\, also auch Verteilerdosen.\n"..
"\n"..
"Da die Stromkabel nicht automatisch geschützt sind\\, wird für längere Strecken die Überlandleitungen (TA Stromleitung) empfohlen.\n"..
"\n"..
"Stromkabel können mit der Kelle verputzt also in der Wand oder im Boden versteckt werden. Als Material zum Verputzen können alle Stein-\\, Clay- und sonstige Blöcke ohne \"Intelligenz\" genutzt werden. Erde (dirt) geht nicht\\, da Erde zu Gras oder ähnlichem konvertiert werden kann\\, was die Leitung zerstören würde.\n"..
"\n"..
"Zum Verputzen muss mit der Kelle auf das Kabel geklickt werden. Das Material\\, mit dem das Kabel verputzt werden soll\\, muss sich im Spieler-Inventar ganz links befinden.\n"..
"Die Kabel können wieder sichtbar gemacht werden\\, indem man mit der Kelle wieder auf den Block klickt.\n"..
"\n"..
"Außer Kabel können auch die TA Verteilerdose und die TA Stromschalterbox verputzt werden.\n"..
"\n"..
"\n"..
"\n",
"Mit der Verteilerdose kann Strom in bis zu 6 Richtungen verteilt werden. Verteilerdosen können auch mit der Kelle verputzt (versteckt) und wieder sichtbar gemacht werden.\n"..
"\n"..
"\n"..
"\n",
"Mit der TA Stromleitung und den Strommasten können halbwegs realistische Überlandleitungen realisiert werden. Die Strommasten-Köpfe dienen gleichzeitig zum Schutz der Stromleitung (Protection). Dazu muss alle 16 m oder weniger ein Masten gesetzt werden. Der Schutz gilt aber nur die die Stromleitung und die Masten\\, alle anderen Blöcke in diesem Bereich sind dadurch nicht geschützt.\n"..
"\n"..
"\n"..
"\n",
"Dient zum Bauen von Strommasten. Ist durch den Strommast-Kopf vor Zerstörung geschützt und kann nur vom Besitzer wieder abgebaut werden.\n"..
"\n"..
"\n"..
"\n",
"Hat bis zu vier Arme und erlaubt damit\\, Strom in bis zu 6 Richtungen weiter zu verteilen. \n"..
"Der Strommastkopf schützt Stromleitungen und Masten in einem Radius von 8 m.\n"..
"\n"..
"\n"..
"\n",
"Dieser Strommastkopf hat zwei feste Arme und wird für die Überlandleitungen genutzt. Er kann aber auch Strom nach unten und oben weiterleiten.\n"..
"Der Strommastkopf schützt Stromleitungen und Masten in einem Radius von 8 m.\n"..
"\n"..
"\n"..
"\n",
"Mit dem Schalter kann der Strom ein- und ausgeschaltet werden. Der Schalter muss dazu auf eine Stromschalterbox gesetzt werden. Die Stromschalterbox muss dazu auf beiden Seiten mit dem Stromkabel verbunden sein.\n"..
"\n"..
"\n"..
"\n",
"Mit dem Schalter kann der Strom ein- und ausgeschaltet werden. Der Schalter muss dazu auf eine Stromschalterbox gesetzt werden. Die Stromschalterbox muss dazu auf beiden Seiten mit dem Stromkabel verbunden sein.\n"..
"\n"..
"\n"..
"\n",
"siehe TA Stromschalter.\n"..
"\n"..
"\n"..
"\n",
"Der kleine Stromgenerator wird mit Benzin betrieben und kann für kleine Verbraucher mit bis zu 12 ku genutzt werden. Unter Volllast brennt Benzin 150 s. Unter Teillast entsprechend länger (50% Last = doppelte Zeit).\n"..
"\n"..
"Der Stromgenerator kann nur 50 Einheiten Benzin aufnehmen. Ein zusätzlicher Tank und eine Pumpe sind daher ratsam.\n"..
"\n"..
"\n"..
"\n",
"Der Akku Block dient zur Speicherung von überschüssiger Energie und gibt bei Stromausfall automatisch Strom ab (soweit vorhanden).\n"..
"Mehrere Akku Blocks zusammen bilden ein TA3 Energiespeichersystem. Jeder Akku Block hat eine Anzeige für den Ladezustand und für die gespeicherte Ladung\\, wobei hier immer die Werte für das gesamte Netzwerk angezeigt werden. Die gespeicherte Ladung wird in \"kud\" also \"ku-days\" angezeigt (analog zu kWh) 5 kud entspricht damit bspw. 5 ku für einen Spieltag (20 min) oder 1 ku für 5 Spieltage.\n"..
"\n"..
"Ein Akku Block hat 3.33 kud.\n"..
"\n"..
"\n"..
"\n",
"Das Strom-Terminal muss mit dem Stromnetz verbunden werden. Es zeigt Daten aus dem Stromnetz an.\n"..
"\n"..
"In der oberen Hälfte werden die wichtigsten Größen ausgegeben:\n"..
"\n"..
" - aktuelle/maximale Generatorleistung\n"..
" - aktueller Stromaufnahme aller Verbraucher\n"..
" - aktueller Ladestrom in/aus dem Speichersystems\n"..
" - aktuellen Ladezustand des Speichersystems in Prozent\n"..
"\n"..
"In der unteren Hälfte wird die Anzahl der Netzwerkblöcke ausgegeben.\n"..
"\n"..
"Über den Reiter \"console\" können weitere Daten zu den Generatoren und Speichersystemen abgefragt werden.\n"..
"\n"..
"\n"..
"\n",
"Um TA2 Maschinen über das Stromnetz betreiben zu können\\, wird der TA3 Elektromotor benötigt. Dieser wandelt Strom in Achsenkraft um.\n"..
"Wird der Elektromotor nicht mit ausreichend Strom versorgt\\, geht er in einen Fehlerzustand und muss über einen Rechtsklick wieder aktiviert werden.\n"..
"\n"..
"Das Elektromotor nimmt primär max. 40 ku an Strom auf und gibt sekundär max. 39 ku als Achsenkraft wieder ab. Er verbraucht also ein ku für die Umwandlung.\n"..
"\n"..
"\n"..
"\n",
"Der TA3 Industrieofen dient als Ergänzung zu normalen Ofen (furnace). Damit können alle Waren mit \"Koch\" Rezepten\\, auch im Industrieofen hergestellt werden. Es gibt aber auch spezielle Rezepte\\, die nur im Industrieofen hergestellt werden können.\n"..
"Der Industrieofen hat sein eigenes Menü zur Rezeptauswahl. Abhängig von den Waren im Industrieofen Inventar links kann rechts das Ausgangsprodukt gewählt werden.\n"..
"\n"..
"Der Industrieofen benötigt Strom (für das Gebläse) sowie Schweröl/Benzin für den Brenner. Der Industrieofen muss wie im Plan rechts abgebildet\\, zusammen gebaut werden.\n"..
"\n"..
"Siehe auch TA4 Ofenheizung.\n"..
"\n"..
"\n"..
"\n",
"Ist Teil des TA3 Industrieofen.\n"..
"\n"..
"Der Ölbrenner kann mit Erdöl\\, Schweröl\\, Naphtha oder Benzin betrieben werden. Die Brennzeit beträgt für Erdöl 65 s\\, Schweröl 80 s\\, Naphtha 90 s und Benzin 100 s.\n"..
"\n"..
"Der Ölbrenner kann nur 50 Einheiten Kraftstoff aufnehmen. Ein zusätzlicher Tank und eine Pumpe sind daher ratsam.\n"..
"\n"..
"\n"..
"\n",
"Ist Teil des TA3 Industrieofen. Siehe TA3 Industrieofen.\n"..
"\n"..
"\n"..
"\n",
"Ist Teil des TA3 Industrieofen. Siehe TA3 Industrieofen.\n"..
"\n"..
"\n"..
"\n",
"Flüssigkeiten wie Wasser oder Öl können nur die spezielle Leitungen gepumpt und in Tanks gespeichert werden. Wie auch bei Wasser gibt es aber Behälter (Kanister\\, Fässer)\\, in denen die Flüssig gelagert und transportiert werden kann.\n"..
"\n"..
"Über die gelben Leitungen und Verbindungsstücke ist es auch möglich\\, mehrere Tanks zu verbinden. Allerdings müssen die Tanks den selben Inhalt haben und zwischen Tank\\, Pumpe und Verteiler muss immer mindestens eine gelbe Leitung sein.\n"..
"\n"..
"Bspw. zwei Tanks direkt mit einem Verteilerstück zu verbinden\\, geht nicht.\n"..
"\n"..
"Um Flüssigkeiten von Behältern nach Tanks umzufüllen\\, dient der Einfülltrichter. Im Plan ist dargestellt\\, wie Kanistern oder Fässer mit Flüssigkeiten über Schieber in einen Einfülltrichter geschoben werden. Im Einfülltrichter wird der Behälter geleert und die Flüssigkeit nach unten in den Tank geleitet. \n"..
"\n"..
"Der Einfülltrichter kann auch unter einen Tank gesetzt werden\\, um den Tank zu leeren.\n"..
"\n"..
"\n"..
"\n",
"In einem Tank können Flüssigkeiten gespeichert werden. Ein Tank kann über eine Pumpe gefüllt bzw. geleert werden. Dazu muss die Pumpe über einer Leitung (gelbe Röhre) mit dem Tank verbunden sein.\n"..
"\n"..
"Ein Tank kann auch von Hand gefüllt oder geleert werden\\, indem mit einem vollen oder leeren Flüssigkeitsbehälter (Fass\\, Kanister) auf den Tank geklickt wird. Dabei ist zu beachten\\, dass Fässer nur komplett gefüllt oder entleert werden können. Sind bspw. weniger als 10 Einheiten im Tank\\, muss dieser Rest mit Kanistern entnommen oder leergepumpt werden.\n"..
"\n"..
"In einen TA3 Tank passen 1000 Einheiten oder 100 Fässer einer Flüssigkeit.\n"..
"\n"..
"\n"..
"\n",
"Mit der Pumpe können Flüssigkeiten von Tanks oder Behältern zu anderen Tanks oder Behältern gepumpt werden. Bei der Pumpe muss die Pumprichtung (Pfeil) beachtet werden. Über die gelben Leitungen und Verbindungsstücke ist es auch möglich\\, mehrere Tanks auf jeder Seite der Pumpe anzuordnen. Allerdings müssen die Tanks den selben Inhalt haben.\n"..
"\n"..
"Die TA3 Pumpe pumpt 4 Einheiten Flüssigkeit alle zwei Sekunden.\n"..
"\n"..
"Hinweis 1: Die Pumpe darf nicht direkt neben den Tank platziert werden. Es muss immer mindestens ein Stück gelbe Leitung dazwischen sein.\n"..
"\n"..
"Hinweis 2: Nach dem Starten markiert die Pumpe 10 x die Blöcke\\, von und zu denen gepumpt wird.\n"..
"\n"..
"\n"..
"\n",
"Um Flüssigkeiten zwischen Behältern und Tanks umzufüllen\\, dient der Einfülltrichter.\n"..
"\n"..
" - wird der Einfülltrichter unter einen Tank gesetzt und werden leere Fässer mit einem Schieber oder von Hand in den Einfülltrichter gegeben\\, wird der Tankinhalt in die Fässer umgefüllt und die Fässer können ausgangsseitig wieder entnommen werden\n"..
" - wird der Einfülltrichter auf einen Tank gesetzt und werden volle Fässer mit einem Schieber oder von Hand in den Einfülltrichter gegeben\\, werden diese in den Tank umgefüllt und die Fässer können ausgangsseitig wieder entnommen werden\n"..
"\n"..
"Dabei ist zu beachten\\, dass Fässer nur komplett gefüllt oder entleert werden können. Sind bspw. weniger als 10 Einheiten im Tank\\, muss dieser Rest mit Kanistern entnommen oder leergepumpt werden.\n"..
"\n"..
"\n"..
"\n",
"Die gelben Röhren dienen zur Weiterleitung von Gas und Flüssigkeiten. \n"..
"Die maximale Leitungslänge beträgt 100 m.\n"..
"\n"..
"\n"..
"\n",
"Die Blöcke dienen als Wanddurchbrüche für Röhren\\, so dass keine Löcher offen bleiben.\n"..
"\n"..
"\n"..
"\n",
"Für die gelben Röhren gibt es ein Ventil\\, welches über Mausklicks geöffnet und geschlossen werden kann.\n"..
"Das Ventil kann auch über on/off Kommandos angesteuert werden.\n"..
"\n"..
"\n"..
"\n",
"Um deine Generatoren und Öfen mit Öl betreiben zu können\\, muss du zuerst nach Öl suchen und einen Bohrturm errichten und danach das Öl fördern.\n"..
"Dazu dienen dir TA3 Ölexplorer\\, TA3 Ölbohrkiste und TA3 Ölpumpe.\n"..
"\n"..
"\n"..
"\n",
"Mit dem Ölexplorer kannst du nach Öl suchen. Dazu den Block auf den Boden setzen und mit Rechtsklick die Suche starten. Der Ölexplorer kann oberirdisch und unterirdisch in allen Tiefen eingesetzt werden.\n"..
"Über die Chat-Ausgabe wird dir angezeigt\\, in welcher Tiefe nach Öl gesucht wurde und wie viel Öl (oil) gefunden wurde.\n"..
"Du kannst mehrfach auf den Block klicken\\, um auch in tieferen Bereichen nach Öl zu suchen. Ölfelder haben eine Größe von 4000 bis zu 20000 Items.\n"..
"\n"..
"Falls die Suche erfolglos war\\, musst du den Block ca. 16 m weiter setzen.\n"..
"Der Ölexplorer sucht immer innerhalb des ganzen Map-Blocks und darunter nach Öl\\, in dem er gesetzt wurde. Eine erneute Suche im gleichen Map-Block (16x16 Feld) macht daher keinen Sinn.\n"..
"\n"..
"Falls Öl gefunden wurde\\, wird die Stelle für den Bohrturm angezeigt. Du musst den Bohrturm innerhalb des angezeigten Bereiches errichten\\, die Stelle am besten gleich mit einem Schild markieren und den ganzen Bereich gegen fremde Spieler schützen.\n"..
"\n"..
"Gib die Suche nach Öl nicht zu schnell auf. Es kann wenn du Pech hast\\, sehr lange dauern\\, bis du eine Ölquelle gefunden hast.\n"..
"Es macht auch keinen Sinn\\, einen Bereich den ein anderer Spieler bereits abgesucht hat\\, nochmals abzusuchen. Die Chance\\, irgendwo Öl zu finden\\, ist für alle Spieler gleich.\n"..
"\n"..
"Der Ölexplorer kann immer wieder zur Suche nach Öl eingesetzt werden.\n"..
"\n"..
"\n"..
"\n",
"Die Ölbohrkiste muss an die Stelle gesetzt werden\\, die vom Ölexplorer angezeigt wurde. An anderen Stellen nach Öl zu bohren ist zwecklos.\n"..
"Wird auf den Button der Ölbohrkiste geklickt\\, wird über der Kiste ein Bohrturm errichtet. Dies dauert einige Sekunden.\n"..
"Die Ölbohrkiste hat 4 Seiten\\, bei IN muss das Bohrgestänge über Schieber angeliefert und bei OUT muss das Bohrmaterial abtransportiert werden. Über eine der anderen zwei Seiten muss die Ölbohrkiste mit Strom versorgt werden.\n"..
"\n"..
"Die Ölbohrkiste bohrt bis zum Ölfeld (1 Meter in 16 s) und benötigt dazu 16 ku Strom.\n"..
"Wurde das Ölfeld erreicht\\, kann der Bohrturm abgebaut und die Kiste entfernt werden.\n"..
"\n"..
"\n"..
"\n",
"An die Stelle der Ölbohrkiste muss nun die Ölpumpe platziert werden. Auch die Ölpumpe benötigt Strom (16 ku) und liefert alle 8 s ein Einheit Erdöl. Das Erdöl muss in einem Tank gesammelt werden. Dazu muss die Ölpumpe über eine Leitung (gelbe Röhre) mit dem Tank verbunden werden.\n"..
"Ist alles Öl abgepumpt\\, kann auch die Ölpumpe wieder entfernt werden.\n"..
"\n"..
"\n"..
"\n",
"Das Bohrgestänge wird für die Bohrung benötigt. Es werden so viele Bohrgestänge Items benötigt wie als Tiefe für das Ölfeld angegeben wurde. Das Bohrgestänge ist nach der Bohrung nutzlos\\, kann aber auch nicht abgebaut werden und verbleibt im Boden. Es gibt aber ein Werkzeug\\, um die Bohrgestänge Blöcke wieder entfernen zu können (-> Werkzeuge -> TA3 Bohrgestängezange).\n"..
"\n"..
"\n"..
"\n",
"Der Öltank ist die große Ausführung des TA3 Tanks (siehe Flüssigkeiten -> TA3 Tank).\n"..
"\n"..
"Der große Tank kann 4000 Einheiten Öl\\, aber auch jede andere Art von Flüssigkeit aufnehmen.\n"..
"\n"..
"\n"..
"\n",
"",
"Um Öl von der Ölquelle zur Ölverarbeitungsanlage zu befördern\\, können Tankwagen (tank carts) genutzt werden. Ein Tankwagen kann direkt über Pumpen gefüllt bzw. geleert werden. In beiden Fällen muss die gelbe Röhre von oben mit dem Tankwagen verbunden werden.\n"..
"\n"..
"Dazu sind folgende Schritte notwendig:\n"..
"\n"..
" - Den Tankwagen vor den Prellbock setzen. Der Prellbock darf noch nicht mit einer Zeit programmiert sein\\, so dass der Tankwagen nicht automatisch losfährt\n"..
" - Den Tankwagen über gelbe Röhren mit der Pumpe verbinden\n"..
" - Pumpe einschalten\n"..
" - Prellbock mit einer Zeit (10 - 20 s) programmieren\n"..
"\n"..
"Diese Reihenfolge muss auf beiden Seiten /Füllen/Leeren) eingehalten werden.\n"..
"\n"..
"\n"..
"\n",
"In die Minecarts können Kanister und Fässer geladen werden. Das Öl muss dazu zuvor in Fässer umgeladen werden. Die Ölfässer können direkt mit einem Schieber und Röhren in das Minecart geschoben werden (siehe Plan). Die leeren Fässer\\, welche per Minecart von der Entladestation zurück kommen\\, können über einen Hopper entladen werden\\, der unter der Schiene an der Haltestelle platziert wird.\n"..
"\n"..
"Es ist mit dem Hopper nicht möglich\\, an *einer* Haltestelle sowohl die leeren Fässer zu entladen\\, als auch die vollen Fässer zu beladen. Der Hopper lädt die vollen Fässer sofort wieder aus. Daher ist es ratsam\\, jeweils 2 Stationen auf der Be- und Entladeseite einzurichten und den Minecart dann über eine Aufzeichnungsfahrt entsprechend zu programmieren.\n"..
"\n"..
"Der Plan zeigt\\, wie das Öl in einen Tank gepumpt und über einen Einfülltrichter in Fässer umgefüllt und in Minecarts geladen werden kann.\n"..
"\n"..
"Damit die Minecarts automatisch wieder starten\\, müssen die Prellböcke mit Stationsname und Wartezeit konfiguriert werden. Für das Entladen reichen 5 s. Da aber die Schieber immer für mehrere Sekunden in den Standby fallen\\, wenn kein Minecart da ist\\, muss für das Beladen eine Zeit von 15 oder mehr Sekunden eingegeben werden.\n"..
"\n"..
"\n"..
"\n",
"Der Tankwagen dient zum Transport von Flüssigkeiten. Es kann wie Tanks mit Pumpen gefüllt bzw. geleert werden. In beiden Fällen muss die gelbe Röhre von oben mit dem Tankwagen verbunden werden.\n"..
"\n"..
"In den Tankwagen passen 200 Einheiten.\n"..
"\n"..
"\n"..
"\n",
"Der Kistenwagen dient zum Transport von Items. Es kann wie Kisten über Schieber gefüllt bzw. geleert werden.\n"..
"\n"..
"In den Kistenwagen passen 4 Stacks.\n"..
"\n"..
"\n"..
"\n",
"Öl ist ein Stoffgemisch und besteht aus sehr vielen Komponenten. Über einen Destillationsturm kann das Öl in seine Hauptbestandteile wie Bitumen\\, Schweröl\\, Naphtha\\, Benzin und Gas zerlegt werden.\n"..
"Die weitere Verarbeitung zu Endprodukten erfolgt im Chemischen Reaktor.\n"..
"\n"..
"\n"..
"\n",
"Der Destillationsturm muss wie im Plan rechts oben aufgebaut werden. \n"..
"Über den Basisblock wird das Bitumen abgelassen. Der Ausgang ist auf der Rückseite des Basisblocks (Pfeilrichtung beachten).\n"..
"Auf diesen Basisblock kommen die \"Destillationsturm\" Blöcke mit den Nummern: 1\\, 2\\, 3\\, 2\\, 3\\, 2\\, 3\\, 4\n"..
"An den Öffnungen von unten nach oben werden Schweröl\\, Naphtha und Benzin abgeleitet. Ganz oben wird das Propangas abgefangen.\n"..
"Es müssen alle Öffnungen am Turm mit Tanks verbunden werden.\n"..
"Der Aufkocher (reboiler) muss mit dem Block \"Destillationsturm 1\" verbunden werden.\n"..
"\n"..
"Der Aufkocher benötigt Strom (nicht im Plan zu sehen)!\n"..
"\n"..
"\n"..
"\n",
"Der Aufkocher erhitzt das Erdöl auf ca. 400°C. Dabei verdampft es weitgehend und wird in den Destillationsturm zur Abkühlung geleitet.\n"..
"\n"..
"Der Aufkocher benötigt 14 Einheiten Strom und produziert alle 16 s jeweils eine Einheit Bitumen\\, Schweröl\\, Naphtha\\, Benzin und Propangas.\n"..
"Dazu muss der Aufkocher über einen Pumpe mit Erdöl versorgt werden.\n"..
"\n"..
"\n"..
"\n",
"Neben den Röhren für Warentransport\\, sowie den Gas- und Stromleitungen gibt es auch noch eine drahtlose Kommunikationsebene\\, über die Blöcke untereinander Daten austauschen können. Dafür müssen keine Leitungen gezogen werden\\, sondern die Verbindung zwischen Sender und Empfänger erfolgt nur über die Blocknummer. \n"..
"\n"..
"*Info:* Eine *Blocknummer* ist eine eindeutige Zahl\\, die von Techage beim Setzen von vielen Techage Blöcken generiert wird. Die Blocknummer dient zur Adressierung bei der Kommunikation zwischen Techage Controllern und Maschinen. Alle Blöcke\\, die an dieser Kommunikation teilnehmen können\\, zeigen die Blocknummer als Info-Text an\\, wenn man mit dem Mauscursor den Block fixiert.\n"..
"\n"..
"Welche Kommandos ein Block unterstützt\\, kann mit dem TechAge Info Werkzeug (Schraubenschlüssel) ausgelesen und angezeigt werden.\n"..
"Die einfachsten Kommandos\\, die von fast allen Blöcken unterstützt werden\\, sind:\n"..
"\n"..
" - 'on' - Block/Maschine/Lampe einschalten\n"..
" - 'off' - Block/Maschine/Lampe ausschalten\n"..
"\n"..
"Mir Hilfe des TA3 Terminal können diese Kommandos sehr einfach ausprobiert werden. Angenommen\\, eine Signallampe hat die Nummer 123.\n"..
"Dann kann mit:\n"..
"\n"..
" cmd 123 on\n"..
"\n"..
"die Lampe ein\\, und mit:\n"..
"\n"..
" cmd 123 off\n"..
"\n"..
"die Lampe wieder ausgeschaltet werden. Diese Kommandos müssen so in das Eingabefeld des TA3 Terminals eingegeben werden.\n"..
"\n"..
"Kommandos wie 'on' und 'off' werden zum Empfänger gesendet\\, ohne dass eine Antwort zurück kommt. Diese Kommandos können daher bspw. mit einem Taster/Schalter auch gleichzeitig an mehrere Empfänger gesendet werden\\, wenn dort im Eingabefeld mehrere Nummern eingegeben werden.\n"..
"\n"..
"Ein Kommandos wie 'state' fordert den Status eines Blockes an. Der Block sendet in Folge seinen Status zurück. Diese Art von bestätigten Kommandos kann gleichzeitig nur an einen Empfänger gesendet werden.\n"..
"Auch dieses Kommandos kann mit dem TA3 Terminal bspw. an einem Schieber ausprobiert werden:\n"..
"\n"..
" cmd 123 state\n"..
"\n"..
"Mögliche Antworten des Schiebers sind:\n"..
"\n"..
" - 'running' --> bin am arbeiten\n"..
" - 'stopped' --> ausgeschaltet\n"..
" - 'standby' --> nichts zu tun\\, da Quell-Inventar leer\n"..
" - 'blocked' --> kann nichts tun\\, da Ziel-Inventar voll\n"..
"\n"..
"Dieser Status und weitere Informationen werden auch ausgegeben\\, wenn mit dem Schraubenschlüssel auf den Block geklickt wird.\n"..
"\n"..
"\n"..
"\n",
"Der Taster/Schalter sendet 'on'/'off' Kommandos zu den Blöcken\\, die über die Nummern konfiguriert wurden.\n"..
"Der Taster/Schalter kann als Taster (button) oder Schalter (switch) konfiguriert werden. Wird er als Taster konfiguriert\\, so kann die Zeit zwischen den 'on' und 'off' Kommandos eingestellt werden. Mit der Betriebsart \"on button\" wird nur ein 'on' und kein 'off' Kommandos gesendet.\n"..
"\n"..
"Über die Checkbox \"public\" kann eingestellt werden\\, ob den Taster von jedem (gesetzt)\\, oder nur vom Besitzer selbst (nicht gesetzt) genutzt werden darf.\n"..
"\n"..
"Hinweis: Mit dem Programmer können Blocknummern sehr einfach eingesammelt und konfiguriert werden.\n"..
"\n"..
"\n"..
"\n",
"Mit dem TA3 Kommando Konverter können 'on' / 'off' Kommandos in andere Kommandos umgewandelt werden\\, sowie die Weiterleitung verhindert oder verzögert werden. Die Nummer des Zielblockes bzw. die Nummern der Zielblöcke\\, die Kommandos die gesendet werden sollen\\, sowie die Verzögerungszeiten in Sekunden müssen eingegeben werden. Wird kein Kommando eingegeben\\, wird nichts gesendet.\n"..
"\n"..
"Die Nummern können auch mit Hilfe des Techage Programmers programmiert werden.\n"..
"\n"..
"\n"..
"\n",
"Das TA3 Flipflop wechselt seinen Zustand mit jedem empfangenen 'on' Kommando. Empfangene 'off' Kommandos werden ignoriert. Damit werden abhängig vom Zustandswechsel abwechselnd 'on' / 'off' Kommandos gesendet. Die Nummer des Zielblockes bzw. die Nummern der Zielblöcke müssen eingegeben werden. Die Nummern können auch mit Hilfe des Techage Programmers programmiert werden.\n"..
"\n"..
"Damit lassen sich bspw. Lampen mit Hilfe von Tastern ein- und wieder ausschalten.\n"..
"\n"..
"\n"..
"\n",
"Den TA3 Logikblock kann man so programmieren\\, dass ein oder mehrere Eingangskommandos zu einem Ausgangskommando verknüpft und gesendet werden. Dieser Block kann daher diverse Logik-Elemente wie AND\\, OR\\, NOT\\, XOR usw. ersetzen.\n"..
"Eingangkommandos für den Logikblock sind 'on'/'off' Kommandos.\n"..
"Eingangskommandos werden über die Nummer referenziert\\, also bspw. '1234' für das Kommando vom Sender mit der Nummer 1234.\n"..
"Das gleiche gilt für Ausgangskommandos.\n"..
"\n"..
"Eine Regel ist wie folgt aufgebaut:\n"..
"\n"..
" <output> = on/off if <input-expression> is true\n"..
"\n"..
"'<output>' ist die Nummer des Blocks\\, zu dem das Kommando gesendet werden soll.\n"..
"'<input-expression>' ist ein boolescher Ausdruck\\, bei dem Eingabenummern ausgewertet werden. \n"..
"\n"..
"*Beispiele für den Input Ausdruck*\n"..
"\n"..
"Signal negieren (NOT):\n"..
"\n"..
" 1234 == off\n"..
"\n"..
"Logisches UND (AND):\n"..
"\n"..
" 1234 == on and 2345 == on\n"..
"\n"..
"Logisches ODER (OR):\n"..
"\n"..
" 1234 == on or 2345 == on\n"..
"\n"..
"Folgende Operatoren sind zulässig: 'and' 'or' 'on' 'off' 'me' '==' '~=' '(' ')'\n"..
"\n"..
"Ist der Ausdruck wahr (true)\\, wird ein Kommando an den Block mit der '<output>' Nummer gesendet.\n"..
"\n"..
"Es können bis zu vier Regeln definiert werden\\, wobei immer alle Regeln geprüft werden\\, wenn ein Kommando empfangen wird.\n"..
"\n"..
"Die interne Durchlaufzeit aller Kommandos beträgt 100 ms.\n"..
"\n"..
"Über das Schlüsselwort 'me' kann die eigene Knotennummer referenziert werden. Damit ist es möglich\\, dass sich der Block selbst ein Kommando sendet (Flip-Flop Funktion).\n"..
"\n"..
"Die Sperrzeit definiert eine Pause nach einem Kommando\\, in der der Logikblock kein weiteres Kommando von extern annimmt. Empfangene Kommandos in der Sperrzeit werden damit verworfen. Die Sperrzeit kann in Sekunden definiert werden.\n"..
"\n"..
"\n"..
"\n",
"Der Wiederholer (repeater) sendet das empfangene Signal an alle konfigurierten Nummern weiter.\n"..
"Dies kann bspw. Sinn machen\\, wenn man viele Blöcke gleichzeitig angesteuert werden sollen. Den Wiederholer kann man dazu mit dem Programmer konfigurieren\\, was nicht bei allen Blöcken möglich ist.\n"..
"\n"..
"\n"..
"\n",
"Der Sequenzer kann eine Reihe von 'on'/'off' Kommandos senden\\, wobei der Abstand zwischen den Kommandos in Sekunden angegeben werden muss. Damit kann man bspw. eine Lampe blinken lassen.\n"..
"Es können bis zu 8 Kommandos konfiguriert werden\\, jedes mit Zielblocknummer und Anstand zum nächsten Kommando.\n"..
"Der Sequenzer wiederholt die Kommandos endlos\\, wenn \"Run endless\" gesetzt wird.\n"..
"Wird also Kommando nichts ausgewählt\\, wird nur die angegeben Zeit in Sekunden gewartet.\n"..
"\n"..
"\n"..
"\n",
"Der Timer kann Kommandos Spielzeit-gesteuert senden. Für jede Kommandozeile kann die Uhrzeit\\, die Zielnummer(n) und das Kommando selbst angegeben werden. Damit lassen sich bspw. Lampen abends ein- und morgens wieder ausschalten.\n"..
"\n"..
"\n"..
"\n",
"Das Terminal dient in erster Linie zum Austesten der Kommandoschnittstelle anderer Blöcke (siehe \"Logik-/Schalt-Blöcke\").\n"..
"Man kann aber auch Kommandos auf Tasten legen und so das Terminal produktiv nutzen.\n"..
"\n"..
" set <button-num> <button-text> <command>\n"..
"\n"..
"Mit 'set 1 ON cmd 123 on' kann bspw. die Usertaste 1 mit dem Kommando 'cnd 123 on' programmiert werden. Wird die Taste gedrückt\\, wird das Kommando gesendet und die Antwort auf dem Bildschirm ausgegeben.\n"..
"\n"..
"Das Terminal besitzt folgende\\, lokalen Kommandos:\n"..
"\n"..
" - 'clear' lösche Bildschirm\n"..
" - 'help' gib eine Hilfeseite aus\n"..
" - 'pub' schalte in den öffentlichen Modus um\n"..
" - 'priv' schalte in den privaten Modus um\n"..
"\n"..
"Im privaten Modus (private) kann das Terminal nur von Spielern verwendet werden\\, die an diesem Ort bauen können\\, also Protection Rechte besitzen. Im öffentlichen Modus (public) können alle Spieler die vorkonfigurierten Tasten verwenden.\n"..
"\n"..
"\n"..
"\n",
"Die Farblampe kann mit 'on'/'off' Kommando ein- bzw. ausgeschaltet werden. Diese Lampe braucht keinen Strom und\n"..
"kann mit der Spritzpistole aus der Mod \"Unified Dyes\" und über Lua/Beduino Kommandos eingefärbt werden.\n"..
"\n"..
"Mit dem Chat-Kommando '/ta_color' wird die Farbpalette mit den Werten für die Lua/Beduino Kommandos angezeigt und mit '/ta_send color <num>' kann die Farbe geändert werden.\n"..
"\n"..
"\n"..
"\n",
"Mit diese Blöcken kann man Türe und Tore realisieren\\, die über Kommandos geöffnet (Blöcke verschwinden) und wieder geschlossen werden können. Pro Tor oder Tür wird dazu ein Tür Controller benötigt. \n"..
"\n"..
"Das Aussehen der Blöcke kann über das Block-Menü eingestellt werden.\n"..
"Damit lassen sich Geheimtüren realisieren\\, die sich nur bei bestimmten Spielern öffnen (mit Hilfe des Spieler-Detektors). \n"..
"\n"..
"\n"..
"\n",
"Der Tür Controller dient zur Ansteuerung der TA3 Tür/Tor Blöcke. Beim Tür Controller müssen die Nummern der Tür/Tor Blöcke eingegeben werden. Wird ein 'on'/'off' Kommando Kommando an den Tür Controller gesendet\\, öffnet/schließt dieser die Tür bzw. das Tor.\n"..
"\n"..
"\n"..
"\n",
"Der Tür Controller II kann alle Arten von Blöcken entfernen und wieder setzen. Um den Tür Controller II anzulernen\\, muss der \"Aufzeichnen\" Button gedrückt werden. Dann müssen alle Blöcke angeklickt werden\\, die Teil der Tür / des Tores sein sollen. Danach muss der \"Fertig\" Button gedrückt werden. Es können bis zu 16 Blöcke ausgewählt werden. Die entfernten Blöcke werden im Inventar des Controllers gespeichert.\n"..
"\n"..
" Über die Tasten \"Entfernen\" bzw. \"Setzen\" kann die Funktion des Controllers von Hand getestet werden.\n"..
"\n"..
"Wird ein 'on' / 'off' Kommando an den Tür Controller II gesendet\\, entfernt bzw. setzt er die Blöcke ebenfalls.\n"..
"\n"..
"Mit '$send_cmnd(node_number\\, \"exchange\"\\, 2)' können einzelne Böcke gesetzt\\, entfernt\\, bzw. durch andere Blöcke aus dem Inventar ersetzt werden. \n"..
"\n"..
"Mit '$send_cmnd(node_number\\, \"set\"\\, 2)' kann ein Block aus dem Inventory explizit gesetzt werden\\, sofern der Inventory Slot nicht leer ist.\n"..
"\n"..
"Mit '$send_cmnd(node_number\\, \"dig\"\\, 2)' kann ein Block wieder entfernt werden\\, sofern der Inventory Slot leer ist. \n"..
"\n"..
"Mit '$send_cmnd(node_number\\, \"get\"\\, 2)' wird der Name des gesetzten Blocks zurückgeliefert. \n"..
"\n"..
"Die Slot-Nummer des Inventars (1 .. 16) muss in allen drei Fällen als payload übergeben werden.\n"..
"\n"..
"Damit lassen sich auch ausfahrbare Treppen und ähnliches simulieren.\n"..
"\n"..
"\n"..
"\n",
"Mir dem Sound Block können veschiedene Sounds/Laute abgespielt werden. Es sind alle Sounds der Mods Techage\\, Signs Bot\\, Hyperloop\\, Unified Inventory\\, TA4 Jetpack und Minetest Game verfügbar.\n"..
"\n"..
"Die Sounds können über das Menü und über ein Kommando ausgewählt und abgespielt werden.\n"..
"\n"..
" - Kommando 'on' zum Abspielen eines Sounds\n"..
" - Kommando 'sound <idx>' zur Auswahl eines Sounds über den Index\n"..
" - Kommando 'gain <volume>' zum Einstellen der Lautstärke über den '<volume>' Wert (1 bis 5).\n"..
"\n"..
"\n"..
"\n",
"Der Mesecons Umsetzer dient zur Umwandlung von Techage on/off Kommandos in Mesecons Signale und umgekehrt.\n"..
"Dazu müssen eine oder mehrere Knotennummern eingegeben und der Konverter mit Mesecons Blöcken \n"..
"über Mesecons Leitungen verbunden werden. Den Mesecons Umsetzer kann man auch mit dem Programmer konfigurieren.\n"..
"Der Mesecons Umsetzer akzeptiert bis zu 5 Kommandos pro Sekunde\\, bei höherer Belastung schaltet er sich ab.\n"..
"\n"..
"*Dieser Block existiert aber nur\\, wenn die Mod mesecons aktiv ist!*\n"..
"\n"..
"\n"..
"\n",
"Detektoren scannen ihre Umgebung ab und senden ein 'on'-Kommando\\, wenn das Gesuchte erkannt wurde.\n"..
"\n"..
"\n"..
"\n",
"Der Detektor ist eine spezieller Röhrenblock\\, der erkennt\\, wenn Items über die Röhre weitergegeben werden. Es muss dazu auf beiden Seiten mit der Röhre verbunden sein. Werden Items mit einem Schieber in den Detektor geschoben\\, gibt er diese automatisch weiter.\n"..
"Er sendet ein 'on'\\, wenn ein Item erkannt wird\\, gefolgt von einem 'off' eine Sekunde später.\n"..
"Danach werden weitere Kommando für 8 Sekunden blockiert.\n"..
"Die Wartezeit\\, sowie die Items\\, die ein Kommando auslösen sollen\\, können über das Gabelschlüssel-Menü konfiguriert werden.\n"..
"\n"..
"\n"..
"\n",
"Der Wagen Detektor sendet ein 'on'-Kommando\\, wenn er einen Wagen/Cart (Minecart) direkt vor sich erkannt hat. Zusätzlich kann der Detektor auch den Wagen wieder starten\\, wenn ein 'on'-Kommando empfangen wird.\n"..
"\n"..
"Der Detektor kann auch mit seiner eigenen Nummer programmiert werden. In diesem Falle schiebt er alle Wagen an\\, die in seiner Nähe (ein Block in alle Richtungen) zum Halten kommen.\n"..
"\n"..
"\n"..
"\n",
"Der Block Detektor sendet ein 'on'-Kommando\\, wenn er erkennt\\, dass Blöcke vor ihm erscheinen oder verschwinden\\, muss jedoch entsprechend konfiguriert werden. Nach dem Zurückschalten des Detektors in den Standardzustand (grauer Block) wird ein 'off'-Kommando gesendet. Gültige Blöcke sind alle Arten von Blöcken und Pflanzen\\, aber keine Tiere oder Spieler. Die Sensorreichweite beträgt 3 Blöcke/Meter in Pfeilrichtung.\n"..
"\n"..
"\n"..
"\n",
"Der Spieler Detektor sendet ein 'on'-Kommando\\, wenn er einen Spieler in einem Umkreis von 4 m um den Block herum erkennt. Verlässt der Spieler wieder den Bereich\\, wird ein 'off'-Kommando gesendet.\n"..
"Soll die Suche auf bestimmte Spieler eingegrenzt werden\\, so können diese Spielernamen auch eingegeben werden.\n"..
"\n"..
"\n"..
"\n",
"Der Lichtdetektor sendet einen 'on'-Kommando\\, wenn der Lichtpegel des darüber liegenden Blocks einen bestimmten Pegel überschreitet\\, der über das Rechtsklickmenü eingestellt werden kann.\n"..
"Mit einen TA4 Lua Controller kann die genaue Lichtstärke mit $get_cmd(num\\, 'light_level') ermitteln werden.\n"..
"\n"..
"\n"..
"\n",
"Bei TA3 existieren die gleichen Maschinen wie bei TA2\\, nur sind diese hier leistungsfähiger und benötigen Strom statt Achsenantrieb.\n"..
"Im folgenden sind daher nur die unterschiedlichen\\, technischen Daten angegeben.\n"..
"\n"..
"\n"..
"\n",
"Die Funktion entspricht der von TA2.\n"..
"Die Verarbeitungsleistung beträgt 6 Items alle 2 s.\n"..
"\n"..
"\n"..
"\n",
"Die Funktion des TA3 Verteilers entspricht der von TA2.\n"..
"Die Verarbeitungsleistung beträgt 12 Items alle 4 s.\n"..
"\n"..
"\n"..
"\n",
"Die Funktion entspricht der von TA2.\n"..
"Die Verarbeitungsleistung beträgt 2 Items alle 4 s. Der Autocrafter benötigt hierfür 6 ku Strom.\n"..
"\n"..
"\n"..
"\n",
"Die Funktion entspricht der von TA2\\, nur werden hier TA4 WLAN Chips produziert.\n"..
"Die Verarbeitungsleistung beträgt ein Chip alle 6 s. Der Block benötigt hierfür 12 ku Strom.\n"..
"\n"..
"\n"..
"\n",
"Die Funktion entspricht der von TA2.\n"..
"Die maximale Tiefe beträgt 40 Meter. Der Steinbrecher benötigt 12 ku Strom.\n"..
"\n"..
"\n"..
"\n",
"Die Funktion entspricht der von TA2.\n"..
"Die Verarbeitungsleistung beträgt 2 Items alle 4 s. Der Block benötigt 4 ku Strom.\n"..
"\n"..
"\n"..
"\n",
"Die Funktion entspricht der von TA2.\n"..
"Auch die Wahrscheinlichkeit ist wie bei TA2. Der Block benötigt auch 3 ku Strom.\n"..
"Aber im Gegensatz zu TA2 kann beim TA3 Block bspw. der Status abgefragt werden (Controller)\n"..
"\n"..
"\n"..
"\n",
"Die Funktion entspricht der von TA2.\n"..
"Die Verarbeitungsleistung beträgt 2 Items alle 4 s. Der Block benötigt 6 ku Strom.\n"..
"\n"..
"\n"..
"\n",
"Der Injektor ist ein TA3 Schieber mit speziellen Eigenschaften. Er besitzt ein Menü zur Konfiguration. Hier können bis zu 8 Items konfiguriert werden. Er entnimmt nur diese Items einer Kiste um sie an Maschinen mit Rezepturen weiterzugeben (Autocrafter\\, Industrieofen und Elektronikfabrik).\n"..
"\n"..
"Beim Weitergeben wird in der Zielmaschine pro Item nur eine Position im Inventar genutzt. Sind bspw. nur die ersten drei Einträge im Injektor konfiguriert\\, so werden auch nur die ersten drei Speicherplätze im Inventar der Maschine belegt. Damit wir ein Überlauf im Inventar der Maschine verhindert.\n"..
"\n"..
"Der Injektor kann auch auf \"Ziehe-Modus\" umgeschaltet werden. Dann zieht er nur Items von den Positionen aus der Kiste\\, die in der Konfiguration des Injektors definiert sind. Hier müssen also Item-Typ und Position überein stimmen. Damit können geziehlt Speicherplätze im Inventar einer Kiste geleert werden.\n"..
"\n"..
"Die Verarbeitungsleistung beträgt bis zu 8 mal ein Item alle 4 Sekunden.\n"..
"\n"..
"\n"..
"\n",
"",
"Das Techage Info Tool (Schraubenschlüssel) hat verschiedene Funktionen. Er zeigt die Uhrzeit\\, die Position\\, die Temperatur und das Biome an\\, wenn auf einen unbekannten Block geklickt wird.\n"..
"Wird auf einen TechAge Block mit Kommandoschnittstelle geklickt\\, werden alle verfügbaren Daten abgerufen (siehe auch \"Logik-/Schalt-Blöcke\").\n"..
"\n"..
"Mit Shift+Rechtsklick kann bei einigen Blöcken ein erweitertes Menü geöffnet werden. Hier lassen sich je nach Block weitere Daten abrufen oder spezielle Einstellungen vornehmen. Bei einem Generator kann bspw. die Ladekurve/abschaltung programmiert werden. \n"..
"\n"..
"\n"..
"\n",
"Mit dem Programmer können Blocknummern mit einem Rechtsklick von mehreren Blöcken eingesammelt und mit einem Linksklick in einen Block wie Taster/Schalter geschrieben werden.\n"..
"Wird in die Luft geklickt\\, wird der interne Speicher gelöscht.\n"..
"\n"..
"\n"..
"\n",
"Die Kelle dient zum Verputzen von Stromkabel. Siehe dazu \"TA Stromkabel\".\n"..
"\n"..
"\n"..
"\n",
"Mit diesem Werkzeug lassen sich die Bohrgestängezange Blöcke wieder entfernen\\, wenn dort bspw. ein Tunnel durch soll.\n"..
"\n"..
"\n"..
"\n",
"Der Techage Schraubendreher dient als Ersatz für den normalen Schraubendreher. Es besitzt folgende Funktionen:\n"..
"\n"..
" - Linksklick: Den Block nach links drehen\n"..
" - Rechtsklick: Die sichtbare Seite des Blockes nach oben drehen\n"..
" - Shift+Linksklick: Ausrichtung des angeklickten Blockes speichern\n"..
" - Shift+Rechtsklick: Die gespeicherte Ausrichtung auf den angeklickten Block anwenden\n"..
"\n"..
"\n"..
"\n",
"Das TechAge Montagewerkzeug dient zum Entfernen und wieder Setzen von Techage Blöcken\\, ohne dass diese Blöcke ihre Blocknummer verlieren\\, bzw. beim Setzen eine neue Nummer zugeteilt bekommen. Dies ist bspw. bei Steinbrechern hilfreich\\, da diese oft umgesetzt werden müssen.\n"..
"\n"..
" - Linke Taste: Entfernen eines Blocks\n"..
" - Rechte Taste: Setzen eines Blocks\n"..
"\n"..
"Der Block\\, der zuvor mit dem Montagewerkzeug entfernt wurde und wieder gesetzt werden soll\\, muss sich im Spieler-Inventar ganz links befinden.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta3",
"",
"ta3_firebox",
"ta3_oilbox",
"ta3_boiler",
"ta3_turbine",
"ta3_generator",
"ta3_cooler",
"ta3_powerswitch",
"power_reduction",
"ta3_powercable",
"ta3_powerjunction",
"ta3_powerline",
"ta3_powerpole",
"ta3_powerpole4",
"ta3_powerpole2",
"ta3_powerswitch",
"ta3_powerswitchsmall",
"ta3_powerswitchbox",
"ta3_tinygenerator",
"ta3_akkublock",
"ta3_powerterminal",
"ta3_motor",
"",
"ta3_furnacefirebox",
"ta3_furnace",
"ta3_booster",
"",
"ta3_tank",
"ta3_pump",
"ta3_filler",
"ta3_pipe",
"ta3_pipe_wall_entry",
"ta3_valve",
"techage_ta3",
"ta3_oilexplorer",
"ta3_drillbox",
"ta3_pumpjack",
"ta3_drillbit",
"oiltank",
"",
"tank_cart",
"",
"tank_cart",
"chest_cart",
"techage_ta31",
"",
"reboiler",
"ta3_logic",
"ta3_button",
"ta3_command_converter",
"ta3_flipflop",
"ta3_logic",
"ta3_repeater",
"ta3_sequencer",
"ta3_timer",
"ta3_terminal",
"ta3_colorlamp",
"ta3_doorblock",
"ta3_doorcontroller",
"ta3_doorcontroller",
"ta3_soundblock",
"ta3_mesecons_converter",
"ta3_nodedetector",
"ta3_detector",
"ta3_cartdetector",
"ta3_nodedetector",
"ta3_playerdetector",
"ta3_lightdetector",
"ta3_grinder",
"ta3_pusher",
"ta3_distributor",
"ta3_autocrafter",
"ta3_electronicfab",
"ta3_quarry",
"ta3_gravelsieve",
"ta3_gravelrinser",
"ta3_grinder",
"ta3_injector",
"",
"ta3_end_wrench",
"ta3_programmer",
"ta3_trowel",
"ta3_drill_pipe_wrench",
"ta3_screwdriver",
"techage:assembly_tool",
},
plans = {
"",
"coalpowerstation",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta3_furnace",
"",
"",
"",
"ta3_tank",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta3_loading",
"",
"",
"",
"ta3_distiller",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

931
doc/manual_ta3_EN.lua Normal file
View File

@ -0,0 +1,931 @@
return {
titles = {
"1,TA3: Oil Age",
"2,Coal-fired Power Station / Oil-fired Power Station",
"3,TA3 power station firebox",
"3,TA3 Power Station Oil Burner",
"3,TA3 boiler base / top",
"3,TA3 turbine",
"3,TA3 generator",
"3,TA3 cooler",
"2,Electrical current",
"3,Importance of storage systems",
"3,TA Electric Cable",
"3,TA Electric Junction Box",
"3,TA Power Line",
"3,TA Power Pole",
"3,TA Power Pole Top",
"3,TA Power Pole Top 2",
"3,TA Power Switch",
"3,TA Power Switch Small",
"3,TA Power Switch Box",
"3,TA3 Small Power Generator",
"3,TA3 Accu Block",
"3,TA3 Power Terminal",
"3,TA3 Electric Motor",
"2,TA3 Industrial Furnace",
"3,TA3 Furnace Oil Burner",
"3,TA3 Furnace Top",
"3,TA3 Booster",
"2,Liquids",
"3,TA3 Tank",
"3,TA3 Pump",
"3,TA Liquid Filler",
"3,TA4 Pipe",
"3,TA3 Pipe Wall Entry Blocks",
"3,TA Valve",
"2,Oil Production",
"3,TA3 Oil Explorer",
"3,TA3 Oil Drill Box",
"3,TA3 Oil Pumpjack",
"3,TA3 Drill Pipe",
"3,Oil tank",
"2,Oil Transportation",
"3,Oil transportation by Tank Carts",
"3,Oil transportation with barrels over Minecarts",
"3,Tank Cart",
"3,Chest Cart",
"2,Oil Processing",
"3,Distillation Tower",
"4,Reboiler",
"2,Logic / Switching Blocks",
"3,TA3 Button / Switch",
"3,TA3 Command Converter",
"3,TA3 Flip-Flop",
"3,TA3 Logic Block",
"3,TA3 Repeater",
"3,TA3 Sequencer",
"3,TA3 Timer",
"3,TA3 Terminal",
"3,TechAge Color Lamp",
"3,Door/Gate Blocks",
"3,TA3 Door Controller",
"3,TA3 Door Controller II",
"3,TA3 Sound Block",
"3,TA3 Mesecons Converter",
"2,Detectors",
"3,TA3 Detector",
"3,TA3 Cart Detector",
"3,TA3 Node Detector",
"3,TA3 Player Detector",
"3,TA3 Light Detector",
"2,TA3 Machines",
"3,TA3 Pusher",
"3,TA3 Distributor",
"3,TA3 Autocrafter",
"3,TA3 Electronic Fab",
"3,TA3 Quarry",
"3,TA3 Gravel Sieve",
"3,TA3 Gravel Rinser",
"3,TA3 Grinder",
"3,TA3 Injector",
"2,Tools",
"3,Techage Info Tool",
"3,TechAge Programmer",
"3,TechAge Trowel / Trowel",
"3,TA3 drill pipe wrench",
"3,Techage Screwdriver",
"3,TechAge Assembly Tool",
},
texts = {
"At TA3 it is important to replace the steam-powered machines with more powerful and electric-powered machines.\n"..
"\n"..
"To do this\\, you have to build coal-fired power plants and generators. You will soon see that your electricity needs can only be met with oil-powered power plants. So you go looking for oil. Drilling derricks and oil pumps help them get the oil. Railways are used to transport oil to the power plants.\n"..
"\n"..
"The industrial age is at its peak.\n"..
"\n"..
"\n"..
"\n",
"The coal-fired power plant consists of several blocks and must be assembled as shown in the plan on the right. The blocks TA3 power station fire box\\, TA3 boiler top\\, TA3 boiler base\\, TA3 turbine\\, TA3 generator and TA3 cooler are required.\n"..
"\n"..
"The boiler must be filled with water. Fill up to 10 buckets of water in the boiler.\n"..
"The fire box must be filled with coal or charcoal.\n"..
"When the water is hot\\, the generator can then be started.\n"..
"\n"..
"Alternatively\\, the power plant can be equipped with an oil burner and then operated with oil.\n"..
"The oil can be refilled using a pump and oil pipe.\n"..
"\n"..
"The power plant delivers an output of 80 ku.\n"..
"\n"..
"\n"..
"\n",
"Part of the power plant.\n"..
"The fire box must be filled with coal or charcoal. The burning time depends on the power that is requested by the power plant. Coal burns for 20 s and charcoal for 60 s under full load. Correspondingly longer under partial load (50% load = double time).\n"..
"\n"..
"\n"..
"\n",
"Part of the power plant.\n"..
"\n"..
"The oil burner can be filled with crude oil\\, fuel oil\\, naphtha or gasoline. The burning time depends on the power that is requested by the power plant. Under full load\\, crude oil burns 15 s\\, fuel oil 20 s\\, naphtha 22 s and gasoline 25 s.\n"..
"\n"..
"Correspondingly longer under partial load (50% load = double time).\n"..
"\n"..
"The oil burner can only hold 50 units of fuel. An additional oil tank and an oil pump are therefore advisable.\n"..
"\n"..
"\n"..
"\n",
"Part of the power plant. Must be filled with water. If there is no more water or the temperature drops too low\\, the power plant switches off.\n"..
"\n"..
"The water consumption of the TA3 boiler is much lower than that of the steam engine due to the closed steam circuit.\n"..
"With the steam engine\\, some water is lost as steam with each piston stroke.\n"..
"\n"..
"\n"..
"\n",
"The turbine is part of the power plant. It must be placed next to the generator and connected to the boiler and cooler via steam pipes as shown in the plan.\n"..
"\n"..
"\n"..
"\n",
"The generator is used to generate electricity. It must be connected to the machines via power cables and junction boxes.\n"..
"\n"..
"\n"..
"\n",
"Used to cool the hot steam from the turbine. Must be connected to the boiler and turbine via steam pipes as shown in the plan.\n"..
"\n"..
"\n"..
"\n",
"In TA3 (and TA4) the machines are powered by electricity. To do this\\, machines\\, storage systems\\, and generators must be connected with power cables.\n"..
"TA3 has 2 types of power cables:\n"..
"\n"..
" - Insulated cables (TA power cables) for local wiring in the floor or in buildings. These cables can be hidden in the wall or in the floor (can be \"plastered\" with the trowel).\n"..
" - Overland lines (TA power line) for outdoor cabling over long distances. These cables are protected and cannot be removed by other players.\n"..
"\n"..
"Several consumers\\, storage systems\\, and generators can be operated together in a power network. Networks can be set up with the help of the junction boxes.\n"..
"If too little electricity is provided\\, consumers run out.\n"..
"In this context\\, it is also important that the functionality of Forceload blocks is understood\\, because generators\\, for example\\, only supply electricity when the corresponding map block is loaded. This can be enforced with a forceload block.\n"..
"\n"..
"In TA4 there is also a cable for the solar system.\n"..
"\n"..
"\n"..
"\n",
"Storage systems in the power grid fulfill two tasks:\n"..
"\n"..
" - To cope with peaks in demand: All generators always deliver just as much power as is needed. However\\, if consumers are switched on/off or there are fluctuations in demand for other reasons\\, consumers can fail for a short time. To prevent this\\, there should always be at least one battery block in every network. This serves as a buffer and compensates for these fluctuations in the seconds range.\n"..
" - To store regenerative energy: Solar and wind are not available 24 hours a day. So that the power supply does not fail when no electricity is produced\\, one or more storage systems must be installed in the network. Alternatively\\, the gaps can also be bridged with oil/coal electricity.\n"..
"\n"..
"A storage system indicates its capacity in kud\\, i.e. ku per day. For example\\, a storage system with 100 kud delivers 100 ku for one game day\\, or 10 ku for 10 game days.\n"..
"\n"..
"All TA3/TA4 energy sources have adjustable charging characteristics. By default this is set to \"80% - 100%\". This means that when the storage system is 80% full\\, the output is reduced further and further until it switches off completely at 100%. If electricity is required in the network\\, 100% will never be reached\\, since the power of the generator has at some point dropped to the electricity demand in the network and the storage system is no longer charged\\, but only the consumers are served.\n"..
"\n"..
"This has several advantages:\n"..
"\n"..
" - The charging characteristics are adjustable. This means\\, for example\\, that oil/coal energy sources can be reduced at 60% and regenerative energy sources only at 80%. This means that oil/coal is only burned if there are not enough renewable energy sources available.\n"..
" - Several energy sources can be operated in parallel and are loaded almost evenly\\, because all energy sources work\\, for example\\, up to 80% of the storage system's charging capacity at their full capacity and then reduce their capacity at the same time.\n"..
" - All storage systems in a network form a large buffer. The charging capacity and the filling level of the entire storage system can always be read in percent on every storage system\\, but also on the electricity terminal.\n"..
"\n"..
" \n"..
"\n",
"For local wiring in the floor or in buildings.\n"..
"Branches can be realized using junction boxes. The maximum cable length between machines or junction boxes is 1000 m. A maximum of 1000 nodes can be connected in a power network. All blocks with power connection\\, including junction boxes\\, count as nodes.\n"..
"\n"..
"Since the power cables are not automatically protected\\, the land lines (TA power line) are recommended for longer distances.\n"..
"\n"..
"Power cables can be plastered with the trowel so they can be hidden in the wall or in the floor. All stone\\, clay and other blocks without \"intelligence\" can be used as plastering material. Dirt does not work because dirt can be converted to grass or the like\\, which would destroy the line.\n"..
"\n"..
"For plastering\\, the cable must be clicked on with the trowel. The material with which the cable is to be plastered must be on the far left in the player inventory.\n"..
"The cables can be made visible again by clicking on the block with the trowel.\n"..
"\n"..
"In addition to cables\\, the TA junction box and the TA power switch box can also be plastered.\n"..
"\n"..
"\n"..
"\n",
"With the junction box\\, electricity can be distributed in up to 6 directions. Junction boxes can also be plastered (hidden) with a trowel and made visible again.\n"..
"\n"..
"\n"..
"\n",
"With the TA power line and the electricity poles\\, reasonably realistic overhead lines can be realized. The power pole heads also serve to protect the power line (protection). A pole must be set every 16 m or less. The protection only applies to the power line and the poles\\, however\\, all other blocks in this area are not protected.\n"..
"\n"..
"\n"..
"\n",
"Used to build electricity poles. Is protected from destruction by the electricity pole head and can only be removed by the owner.\n"..
"\n"..
"\n"..
"\n",
"Has up to four arms and thus allows electricity to be distributed in up to 6 directions.\n"..
"The electricity pole head protects power lines and poles within a radius of 8 m.\n"..
"\n"..
"\n"..
"\n",
"This electricity pole head has two fixed arms and is used for the overhead lines. However\\, it can also transmit current downwards and upwards.\n"..
"The electricity pole head protects power lines and poles within a radius of 8 m.\n"..
"\n"..
"\n"..
"\n",
"The switch can be used to switch the power on and off. To do this\\, the switch must be placed on a power switch box. The power switch box must be connected to the power cable on both sides.\n"..
"\n"..
"\n"..
"\n",
"The switch can be used to switch the power on and off. To do this\\, the switch must be placed on a power switch box. The power switch box must be connected to the power cable on both sides.\n"..
"\n"..
"\n"..
"\n",
"see TA power switch.\n"..
"\n"..
"\n"..
"\n",
"The small power generator runs on gasoline and can be used for small consumers with up to 12 ku. Gasoline burns for 150 s under full load. Correspondingly longer under partial load (50% load = double time).\n"..
"\n"..
"The power generator can only hold 50 units of gasoline. An additional tank and a pump are therefore advisable.\n"..
"\n"..
"\n"..
"\n",
"The accu block (rechargeable battery) is used to store excess energy and automatically delivers power in the event of a power failure (if available).\n"..
"Several accu blocks together form a TA3 energy storage system. Each accu block has a display for the charging state and for the stored load.\n"..
"The values for the entire network are always displayed here. The stored load is displayed in \"kud\" or \"ku-days\" (analogous to kWh) 5 kud thus corresponds\\, for example\\, to 5 ku for a game day (20 min) or 1 ku for 5 game days.\n"..
"\n"..
"A accu block has 3.33 kud\n"..
"\n"..
"\n"..
"\n",
"The power terminal must be connected to the power grid. It shows data from the power grid.\n"..
"\n"..
"The most important figures are displayed in the upper half:\n"..
"\n"..
" - current/maximum generator power\n"..
" - current power consumption of all consumers\n"..
" - current charging current in/from the storage system\n"..
" - Current state of charge of the storage system in percent\n"..
"\n"..
"The number of network blocks is output in the lower half.\n"..
"\n"..
"Additional data on the generators and storage systems can be queried via the \"console\" tab.\n"..
"\n"..
"\n"..
"\n",
"The TA3 Electric Motor is required in order to be able to operate TA2 machines via the power grid. The TA3 Electric Motor converts electricity into axle power.\n"..
"If the electric motor is not supplied with sufficient power\\, it goes into an fault state and must be reactivated with a right-click.\n"..
"\n"..
"The electric motor takes max. 40 ku of electricity and provides on the other side max. 39 ku as axle power. So he consumes one ku for the conversion.\n"..
"\n"..
"\n"..
"\n",
"The TA3 industrial furnace serves as a supplement to normal furnaces. This means that all goods can be produced with \"cooking\" recipes\\, even in an industrial furnace. But there are also special recipes that can only be made in an industrial furnace.\n"..
"The industrial furnace has its own menu for recipe selection. Depending on the goods in the industrial furnace inventory on the left\\, the output product can be selected on the right.\n"..
"\n"..
"The industrial furnace requires electricity (for the booster) and fuel oil / gasoline for the burner. The industrial furnace must be assembled as shown in the plan on the right.\n"..
"\n"..
"See also TA4 heater.\n"..
"\n"..
"\n"..
"\n",
"Is part of the TA3 industrial furnace.\n"..
"\n"..
"The oil burner can be operated with crude oil\\, fuel oil\\, naphtha or gasoline. The burning time is 64 s for crude oil\\, 80 s for fuel oil\\, 90 s for naphtha and 100 s for gasoline.\n"..
"\n"..
"The oil burner can only hold 50 units of fuel. An additional tank and a pump are therefore advisable.\n"..
"\n"..
"\n"..
"\n",
"Is part of the TA3 industrial furnace. See TA3 industrial furnace.\n"..
"\n"..
"\n"..
"\n",
"Is part of the TA3 industrial furnace. See TA3 industrial furnace.\n"..
"\n"..
"\n"..
"\n",
"Liquids such as water or oil can only be pumped through the special pipes and stored in tanks. As with water\\, there are containers (canisters\\, barrels) in which the liquid can be stored and transported.\n"..
"\n"..
"It is also possible to connect several tanks using the yellow pipes and connectors. However\\, the tanks must have the same content and there must always be at least one yellow pipe between the tank\\, pump and distributor pipe.\n"..
"\n"..
"E.g. It is not possible to connect two tanks directly to a distributor pipe.\n"..
"\n"..
"The liquid filler is used to transfer liquids from containers to tanks. The plan shows how canisters or barrels with liquids are pushed into a liquid filler via pushers. The container is emptied in the liquid filler and the liquid is led down into the tank.\n"..
"\n"..
"The liquid filler can also be placed under a tank to empty the tank.\n"..
"\n"..
"\n"..
"\n",
"Liquids can be stored in a tank. A tank can be filled or emptied using a pump. To do this\\, the pump must be connected to the tank via a pipe (yellow pipes).\n"..
"\n"..
"A tank can also be filled or emptied manually by clicking on the tank with a full or empty liquid container (barrel\\, canister). It should be noted that barrels can only be completely filled or emptied. If\\, for example\\, there are less than 10 units in the tank\\, this remainder must be removed with canisters or pumped empty.\n"..
"\n"..
"A TA3 tank can hold 1000 units or 100 barrels of liquid.\n"..
"\n"..
"\n"..
"\n",
"The pump can be used to pump liquids from tanks or containers to other tanks or containers. The pump direction (arrow) must be observed for the pump. The yellow lines and connectors also make it possible to arrange several tanks on each side of the pump. However\\, the tanks must have the same content.\n"..
"\n"..
"The TA3 pump pumps 4 units of liquid every two seconds.\n"..
"\n"..
"Note 1: The pump must not be placed directly next to the tank. There must always be at least a piece of yellow pipe between them.\n"..
"\n"..
"\n"..
"\n",
"The liquid filler is used to transfer liquids between containers and tanks.\n"..
"\n"..
" - If the liquid filler is placed under a tank and empty barrels are put into the liquid filler with a pusher or by hand\\, the contents of the tank are transferred to the barrels and the barrels can be removed from the outlet\n"..
" - If the liquid filler is placed on a tank and if full containers are put into the liquid filler with a pusher or by hand\\, the content is transferred to the tank and the empty containers can be removed on the exit side\n"..
"\n"..
"It should be noted that barrels can only be completely filled or emptied. If\\, for example\\, there are less than 10 units in the tank\\, this remainder must be removed with canisters or pumped empty.\n"..
"\n"..
"\n"..
"\n",
"The yellow pipes are used for the transmission of gas and liquids.\n"..
"The maximum pipe length is 100 m.\n"..
"\n"..
"\n"..
"\n",
"The blocks serve as wall openings for tubes\\, so that no holes remain open.\n"..
"\n"..
"\n"..
"\n",
"There is a valve for the yellow pipes\\, which can be opened and closed with a click of the mouse.\n"..
"The valve can also be controlled via on/off commands.\n"..
"\n"..
"\n"..
"\n",
"In order to run your generators and stoves with oil\\, you must first look for oil and build a derrick and then extract the oil.\n"..
"TA3 oil explorer\\, TA3 oil drilling box and TA3 pump jack are used for this.\n"..
"\n"..
"\n"..
"\n",
"You can search for oil with the oil explorer. To do this\\, place the block on the floor and right-click to start the search. The oil explorer can be used above ground and underground at all depths.\n"..
"The chat output shows you the depth to which oil was searched and how much oil (petroleum) was found.\n"..
"You can click the block multiple times to search for oil in deeper areas. Oil fields range in size from 4\\,000 to 20\\,000 items.\n"..
"\n"..
"If the search was unsuccessful\\, you have to move the block approx. 16 m further.\n"..
"The oil explorer always searches for oil in the whole map block and below\\, in which it was set. A new search in the same map block (16x16 field) therefore makes no sense.\n"..
"\n"..
"If oil is found\\, the location for the derrick is displayed. You have to erect the derrick within the area shown\\, it is best to mark the spot with a sign and protect the entire area against foreign players.\n"..
"\n"..
"Don't give up looking for oil too quickly. If you're unlucky\\, it can take a long time to find an oil well.\n"..
"It also makes no sense to search an area that another player has already searched. The chance of finding oil anywhere is the same for all players.\n"..
"\n"..
"The oil explorer can always be used to search for oil.\n"..
"\n"..
"\n"..
"\n",
"The oil drill box must be placed in the position indicated by the oil explorer. Drilling for oil elsewhere is pointless.\n"..
"If the button on the oil drilling box is clicked\\, the derrick is erected above the box. This takes a few seconds.\n"..
"The oil drilling box has 4 sides\\, at IN the drill pipe has to be delivered via pusher and at OUT the drilling material has to be removed. The oil drilling box must be supplied with power via one of the other two sides.\n"..
"\n"..
"The oil drilling box drills to the oil field (1 meter in 16 s) and requires 16 ku of electricity.\n"..
"Once the oil field has been reached\\, the derrick can be dismantled and the box removed.\n"..
"\n"..
"\n"..
"\n",
"The oil pump (pump-jack) must now be placed in the place of the oil drilling box. The oil pump also requires electricity (16 ku) and supplies one unit of oil every 8 s. The oil must be collected in a tank. To do this\\, the oil pump must be connected to the tank via yellow pipes.\n"..
"Once all the oil has been pumped out\\, the oil pump can also be removed.\n"..
"\n"..
"\n"..
"\n",
"The drill pipe is required for drilling. As many drill pipe items are required as the depth specified for the oil field. The drill pipe is useless after drilling\\, but it also cannot be dismantled and remains in the ground. However\\, there is a tool to remove the drill pipe blocks (-> Tools -> TA3 drill pipe pliers).\n"..
"\n"..
"\n"..
"\n",
"The oil tank is the large version of the TA3 tank (see liquids -> TA3 tank).\n"..
"\n"..
"The large tank can hold 4000 units of oil\\, but also any other type of liquid.\n"..
"\n"..
"\n"..
"\n",
"",
"Tank carts can be used to transport oil from the oil well to the oil processing plant. A tank cart can be filled or emptied directly using pumps. In both cases\\, the yellow pipes must be connected to the tank cart from above.\n"..
"\n"..
"The following steps are necessary:\n"..
"\n"..
" - Place the tank cart in front of the rail bumper block. The bumper block must not yet be programmed with a time so that the tank cart does not start automatically\n"..
" - Connect the tank cart to the pump using yellow pipes\n"..
" - Switch on the pump\n"..
" - Program the bumper with a time (10 - 20 s)\n"..
"\n"..
"This sequence must be observed on both sides (fill / empty).\n"..
"\n"..
"\n"..
"\n",
"Canisters and barrels can be loaded into the Minecarts. To do this\\, the oil must first be transferred to barrels. The oil barrels can be pushed directly into the Minecart with a pusher and tubes (see map). The empty barrels\\, which come back from the unloading station by Minecart\\, can be unloaded using a hopper\\, which is placed under the rail at the stop.\n"..
"\n"..
"It is not possible with the hopper to both *unload the empty barrels and load the full barrels at a stop*. The hopper immediately unloads the full barrels. It is therefore advisable to set up 2 stations on the loading and unloading side and then program the Minecart accordingly using a recording run.\n"..
"\n"..
"The plan shows how the oil can be pumped into a tank and filled into barrels via a liquid filler and loaded into Minecarts.\n"..
"\n"..
"For the Minecarts to start again automatically\\, the bumper blocks must be configured with the station name and waiting time. 5 s are sufficient for unloading. However\\, since the pushers always go into standby for several seconds when there is no Minecart\\, a time of 15 or more seconds must be entered for loading.\n"..
"\n"..
"\n"..
"\n",
"The tank truck is used to transport liquids. Like tanks\\, it can be filled with pumps or emptied. In both cases\\, the yellow tube must be connected to the tank truck from above.\n"..
"\n"..
"200 units fit in the tank truck.\n"..
"\n"..
"\n"..
"\n",
"The chest cart is used to transport items. Like chests\\, it can be filled or emptied using a pusher.\n"..
"\n"..
"4 stacks fit in the chest cart.\n"..
"\n"..
"\n"..
"\n",
"Oil is a mixture of substances and consists of many components. The oil can be broken down into its main components such as bitumen\\, fuel oil\\, naphtha\\, gasoline and propane gas via a distillation tower.\n"..
"Further processing to end products takes place in the chemical reactor.\n"..
"\n"..
"\n"..
"\n",
"The distillation tower must be set up as in the plan at the top right.\n"..
"The bitumen is drained off via the base block. The exit is on the back of the base block (note the direction of the arrow).\n"..
"The \"distillation tower\" blocks with the numbers: 1\\, 2\\, 3\\, 2\\, 3\\, 2\\, 3\\, 4 are placed on this basic block\n"..
"Fuel oil\\, naphtha and gasoline are drained from the openings from bottom to top. The propane gas is caught at the top.\n"..
"All openings on the tower must be connected to tanks.\n"..
"The reboiler must be connected to the \"distillation tower 1\" block.\n"..
"\n"..
"The reboiler needs electricity (not shown in the plan)!\n"..
"\n"..
"\n"..
"\n",
"The reboiler heats the oil to approx. 400 ° C. It largely evaporates and is fed into the distillation tower for cooling.\n"..
"\n"..
"The reboiler requires 14 units of electricity and produces one unit of bitumen\\, fuel oil\\, naphtha\\, gasoline and propane every 16 s.\n"..
"To do this\\, the reboiler must be supplied with oil via a pump.\n"..
"\n"..
"\n"..
"\n",
"In addition to the tubes for goods transport\\, as well as the gas and power pipes\\, there is also a wireless communication level through which blocks can exchange data with each other. No lines have to be drawn for this\\, the connection between transmitter and receiver is only made via the block number. \n"..
"\n"..
"*Info:* A block number is a unique number that is generated by Techage when many Techage blocks are placed. The block number is used for addressing during communication between Techage controllers and machines. All blocks that can participate in this communication show the block number as info text if you fix the block with the mouse cursor.\n"..
"\n"..
"Which commands a block supports can be read out and displayed with the TechAge Info Tool (wrench).\n"..
"The simplest commands supported by almost all blocks are:\n"..
"\n"..
" - 'on' - to turn on block / machine / lamp\n"..
" - 'off' - to turn off the block / machine / lamp\n"..
"\n"..
"With the help of the TA3 Terminal\\, these commands can be tried out very easily. Suppose a signal lamp is number 123.\n"..
"Then with:\n"..
"\n"..
" cmd 123 on\n"..
"\n"..
"the lamp can be turned on and with:\n"..
"\n"..
" cmd 123 off\n"..
"\n"..
"the lamp can be turned off again. These commands must be entered in the input field of the TA3 terminal.\n"..
"\n"..
"Commands such as 'on' and'off' are sent to the recipient without a response coming back. These commands can therefore be sent to several receivers at the same time\\, for example with a push button / switch\\, if several numbers are entered in the input field.\n"..
"\n"..
"A command like 'state' requests the status of a block. The block then sends its status back. This type of confirmed command can only be sent to one recipient at a time.\n"..
"This command can also be tested with the TA3 terminal on a pusher\\, for example:\n"..
"\n"..
" cmd 123 state\n"..
"\n"..
"Possible responses from the pusher are:\n"..
"\n"..
" - 'running' -> I'm working\n"..
" - 'stopped' -> switched off\n"..
" - 'standby' -> nothing to do because source inventory is empty\n"..
" - 'blocked' -> can't do anything because target inventory is full\n"..
"\n"..
"This status and other information is also output when the wrench is clicked on the block.\n"..
"\n"..
"\n"..
"\n",
"The button/switch sends 'on' / 'off' commands to the blocks that have been configured via the numbers.\n"..
"The button/switch can be configured as a button or a switch. If it is configured as a button\\, the time between the 'on' and 'off' commands can be set. With the operating mode \"on button\" only an 'on' and no 'off' command is sent.\n"..
"\n"..
"The checkbox \"public\" can be used to set whether the button can be used by everyone (set) or only by the owner himself (not set).\n"..
"\n"..
"Note: With the programmer\\, block numbers can be easily collected and configured.\n"..
"\n"..
"\n"..
"\n",
"With the TA3 command converter\\, 'on' / 'off' commands can be converted into other commands\\, and forwarding can be prevented or delayed.\n"..
"The number of the target block or the numbers of the target blocks\\, the commands to be sent and the delay times in seconds must be entered. If no command is entered\\, nothing is sent.\n"..
"\n"..
"The numbers can also be programmed using the Techage programmer.\n"..
"\n"..
"\n"..
"\n",
"The TA3 flip-flop changes its state with each received 'on' command. Received 'off' commands are ignored. Depending on the status change\\, 'on' / 'off' commands are sent alternately. The number of the target block or the numbers of the target blocks must be entered. The numbers can also be programmed using the Techage programmer.\n"..
"\n"..
"For example\\, lamps can be switched on and off with the help of buttons.\n"..
"\n"..
"\n"..
"\n",
"The TA3 logic block can be programmed in such a way that one or more input commands are linked to one output command and sent. This block can therefore replace various logic elements such as AND\\, OR\\, NOT\\, XOR etc. \n"..
"Input commands for the logic block are 'on' /'off' commands.\n"..
"Input commands are referenced via the number\\, e.g. '1234' for the command from the sender with the number 1234. \n"..
"The same applies to output commands.\n"..
"\n"..
"A rule is structured as follows: \n"..
"\n"..
" <output> = on/off if <input-expression> is true\n"..
"\n"..
"'<output>' is the block number to which the command should be sent.\n"..
"'<input-expression>' is a boolean expression where input numbers are evaluated.\n"..
"\n"..
"*Examples for the input expression*\n"..
"\n"..
"Negate signal (NOT):\n"..
"\n"..
" 1234 == off\n"..
"\n"..
"Logical AND:\n"..
"\n"..
" 1234 == on and 2345 == on\n"..
"\n"..
"Logical OR:\n"..
"\n"..
" 1234 == on or 2345 == on\n"..
"\n"..
"The following operators are allowed: 'and' 'or' 'on' 'off' 'me' '==' '~=' '(' ')'\n"..
"\n"..
"If the expression is true\\, a command is sent to the block with the '<output>' number. \n"..
"Up to four rules can be defined\\, whereby all rules are always checked when a command is received. \n"..
"The internal processing time for all commands is 100 ms. \n"..
"\n"..
"Your own node number can be referenced using the keyword 'me'. This makes it possible for the block to send itself a command (flip-flop function). \n"..
"\n"..
"The blocking time defines a pause after a command\\, during which the logic block does not accept any further external commands. Commands received during the blocking period are thus discarded. The blocking time can be defined in seconds. \n"..
"\n"..
"\n"..
"\n",
"The repeater sends the received signal to all configured numbers.\n"..
"This can make sense\\, for example\\, if you want to control many blocks at the same time. The repeater can be configured with the programmer\\, which is not possible with all blocks.\n"..
"\n"..
"\n"..
"\n",
"The sequencer can send a series of 'on' / 'off' commands\\, whereby the interval between the commands must be specified in seconds. You can use it to make a lamp blink\\, for example.\n"..
"Up to 8 commands can be configured\\, each with target block number and pending the next command.\n"..
"The sequencer repeats the commands endlessly when \"Run endless\" is set.\n"..
"If nothing is selected\\, only the specified time in seconds is waited for.\n"..
"\n"..
"\n"..
"\n",
"The timer can send commands time-controlled. The time\\, the target number(s) and the command itself can be specified for each command line. This means that lamps can be switched on in the evening and switched off again in the morning.\n"..
"\n"..
"\n"..
"\n",
"The terminal is primarily used to test the command interface of other blocks (see \"Logic / switching blocks\").\n"..
"You can also assign commands to keys and use the terminal productively.\n"..
"\n"..
" set <button-num> <button-text> <command>\n"..
"\n"..
"With 'set 1 ON cmd 123 on'\\, for example\\, user key 1 can be programmed with the command 'cmd 123 on'. If the key is pressed\\, the command is sent and the response is output on the screen.\n"..
"\n"..
"The terminal has the following local commands:\n"..
"\n"..
" - 'clear' clear screen\n"..
" - 'help' output a help page\n"..
" - 'pub' switch to public mode\n"..
" - 'priv' switch to private mode\n"..
"\n"..
"In private mode\\, the terminal can only be used by players who can build at this location\\, i.e. who have protection rights.\n"..
"\n"..
"In public mode\\, all players can use the preconfigured keys.\n"..
"\n"..
"\n"..
"\n",
"The signal lamp can be switched on or off with the 'on' / 'off' command. This lamp does not need electricity and can be colored with the airbrush tool from the mod Unified Dyes\" and via Lua/Beduino commands.\n"..
"\n"..
"With the chat command '/ta_color' the color palette with the values for the Lua/Beduino commands is displayed and with '/ta_send color <num>' the color can be changed.\n"..
"\n"..
"\n"..
"\n",
"With these blocks you can realize doors and gates that can be opened via commands (blocks disappear) and closed again. One door controller is required for each gate or door.\n"..
"\n"..
"The appearance of the blocks can be adjusted via the block menu.\n"..
"This makes it possible to realize secret doors that only open for certain players (with the help of the player detector).\n"..
"\n"..
"\n"..
"\n",
"The door controller is used to control the TA3 door/gate blocks. With the door controller\\, the numbers of the door/gate blocks must be entered. If an 'on' / 'off' command is sent to the door controller\\, this opens/closes the door or gate.\n"..
"\n"..
"\n"..
"\n",
"The Door Controller II can remove and set all types of blocks. To teach in the Door Controller II\\, the \"Record\" button must be pressed. Then all blocks that should be part of the door / gate must be clicked. Then the \"Done\" button must be pressed. Up to 16 blocks can be selected. The removed blocks are saved in the controller's inventory. The function of the controller can be tested manually using the \"Remove\" or \"Set\" buttons. If an 'on' /'off' command is sent to the Door Controller II\\, it removes or sets the blocks as well.\n"..
"\n"..
"With '$send_cmnd(node_number\\, \"exchange\"\\, 2)' individual blocks can be set\\, removed or replaced by other blocks from the inventory. \n"..
"\n"..
"With '$send_cmnd(node_number\\, \"set\"\\, 2)' a block from the inventory can be set explicitly\\, as long as the inventory slot is not empty.\n"..
"\n"..
"A block can be removed again with '$send_cmnd(node_number\\, \"dig\"\\, 2)' if the inventory slot is empty. \n"..
"\n"..
"The name of the set block is returned with '$send_cmnd(node_number\\, \"get\"\\, 2)'.\n"..
"\n"..
"The slot number of the inventory (1 .. 16) must be passed as payload in all three cases.\n"..
"\n"..
"This can also be used to simulate extendable stairs and the like. \n"..
"\n"..
"\n"..
"\n",
"Different sounds can be played with the sound block. All sounds of the Mods Techage\\, Signs Bot\\, Hyperloop\\, Unified Inventory\\, TA4 Jetpack and Minetest Game are available.\n"..
"\n"..
"The sounds can be selected and played via the menu and via command.\n"..
"\n"..
" - Command 'on' to play a sound\n"..
" - Command 'sound <idx>' to select a sound via the index\n"..
" - Command 'gain <volume>' to adjust the volume via the '<volume>' value (1 to 5).\n"..
"\n"..
"\n"..
"\n",
"The Mesecons converter is used to convert Techage on/off commands into Mesecons signals and vice versa.\n"..
"To do this\\, one or more node numbers must be entered and the converter with Mesecons blocks\n"..
"has to be connected via Mesecons cables. The Mesecons converter can also be configured with the programmer.\n"..
"The Mesecons converter accepts up to 5 commands per second\\; it switches itself off at higher loads.\n"..
"\n"..
"*This node only exists if the mod mesecons is active!*\n"..
"\n"..
"\n"..
"\n",
"Detectors scan their surroundings and send an 'on' command when the search is recognized.\n"..
"\n"..
"\n"..
"\n",
"The detector is a special tube block that detects when items are passed on through the tube. To do this\\, it must be connected to tubes on both sides. If items are pushed into the detector with a pusher\\, they are automatically passed on.\n"..
"It sends an 'on' when an item is recognized\\, followed by an 'off' a second later.\n"..
"Then further commands are blocked for 8 seconds.\n"..
"The waiting time and the items that should trigger a command can be configured using the open-ended wrench menu. \n"..
"\n"..
"\n"..
"\n",
"The cart detector sends an 'on' command if it has recognized a cart (Minecart) directly in front of it. In addition\\, the detector can also restart the cart when an 'on' command is received.\n"..
"\n"..
"The detector can also be programmed with its own number. In this case\\, he pushes all the wagons that stop near him (one block in all directions).\n"..
"\n"..
"\n"..
"\n",
"The node detector sends an 'on' command if it detects that nodes (blocks) appear or disappear in front of it\\, but must be configured accordingly. After switching the detector back to the standard state (gray block)\\, an 'off' command is sent. Valid blocks are all types of blocks and plants\\, but not animals or players. The sensor range is 3 blocks / meter in the direction of the arrow.\n"..
"\n"..
"\n"..
"\n",
"The player detector sends an 'on' command if it detects a player within 4 m of the block. If the player leaves the area again\\, an 'off' command is sent.\n"..
"If the search should be limited to specific players\\, these player names can also be entered.\n"..
"\n"..
"\n"..
"\n",
"The light detector sends an 'on' command if the light level of the block above exceeds a certain level\\, which can be set through the right-click menu.\n"..
"If you have a TA4 Lua Controller\\, you can get the exact light level with $get_cmd(num\\, 'light_level')\n"..
"\n"..
"\n"..
"\n",
"TA3 has the same machines as TA2\\, only these are more powerful and require electricity instead of axis drive.\n"..
"Therefore\\, only the different technical data are given below.\n"..
"\n"..
"\n"..
"\n",
"The function corresponds to that of TA2.\n"..
"The processing power is 6 items every 2 s.\n"..
"\n"..
"\n"..
"\n",
"The function of the TA3 distributor corresponds to that of TA2.\n"..
"The processing power is 12 items every 4 s.\n"..
"\n"..
"\n"..
"\n",
"The function corresponds to that of TA2.\n"..
"The processing power is 2 items every 4 s. The autocrafter requires 6 ku of electricity.\n"..
"\n"..
"\n"..
"\n",
"The function corresponds to that of TA2\\, only TA4 WLAN chips are produced here.\n"..
"The processing power is one chip every 6 s. The block requires 12 ku of electricity for this.\n"..
"\n"..
"\n"..
"\n",
"The function corresponds to that of TA2.\n"..
"The maximum depth is 40 meters. The quarry requires 12 ku of electricity.\n"..
"\n"..
"\n"..
"\n",
"The function corresponds to that of TA2.\n"..
"The processing power is 2 items every 4 s. The block requires 4 ku of electricity.\n"..
"\n"..
"\n"..
"\n",
"The function corresponds to that of TA2.\n"..
"The probability is also the same as for TA2. The block also requires 3 ku of electricity.\n"..
"But in contrast to TA2\\, the status of the TA3 block can be read (controller)\n"..
"\n"..
"\n"..
"\n",
"The function corresponds to that of TA2.\n"..
"The processing power is 2 items every 4 s. The block requires 6 ku of electricity.\n"..
"\n"..
"\n"..
"\n",
"The injector is a TA3 pusher with special properties. It has a menu for configuration. Up to 8 items can be configured here. He only takes these items from a chest to pass them on to machines with recipes (autocrafter\\, industrial furnace and electronic fab).\n"..
"\n"..
"When passing on\\, only one position in the inventory is used in the target machine. If\\, for example\\, only the first three entries are configured in the injector\\, only the first three storage locations in the machine's inventory are used. So that an overflow in the machine inventory is prevented.\n"..
"\n"..
"The injector can also be switched to \"pull mode\". Then he only pulls items out of the chest from the positions that are defined in the configuration of the injector. In this case\\, item type and position must match. This allows to empty specific inventory entries of a chest. \n"..
"\n"..
"The processing power is up to 8 times one item every 4 seconds.\n"..
"\n"..
"\n"..
"\n",
"",
"The Techage Info Tool (open-ended wrench) has several functions. It shows the time\\, position\\, temperature and biome when an unknown block is clicked on.\n"..
"If you click on a TechAge block with command interface\\, all available data will be shown (see also \"Logic / switching blocks\").\n"..
"\n"..
"With Shift + right click an extended menu can be opened for some blocks. Depending on the block\\, further data can be called up or special settings can be made here. In the case of a generator\\, for example\\, the charging curve/switch-off can be programmed. \n"..
"\n"..
"\n"..
"\n",
"With the programmer\\, block numbers can be collected from several blocks with a right click and written into a block like a button / switch with a left click.\n"..
"If you click in the air\\, the internal memory is deleted.\n"..
"\n"..
"\n"..
"\n",
"The trowel is used for plastering power cables. See also \"TA power cable\".\n"..
"\n"..
"\n"..
"\n",
"This tool can be used to remove the drill pipe blocks if\\, for example\\, a tunnel is to pass through there.\n"..
"\n"..
"\n"..
"\n",
"The Techage Screwdriver serves as a replacement for the normal screwdriver. It has the following functions:\n"..
"\n"..
" - Left click: turn the block to the left\n"..
" - Right click: turn the visible side of the block upwards\n"..
" - Shift + left click: save the alignment of the clicked block\n"..
" - Shift + right click: apply the saved alignment to the clicked block\n"..
"\n"..
" \n"..
"\n",
"The TechAge Assembly Tool is used to remove and reposition Techage blocks without these blocks losing their block number or being assigned a new number when setting. This is helpful\\, for example\\, for quarries\\, as they often have to be moved.\n"..
"\n"..
" - Left button: Remove a block\n"..
" - Right button: Set a block\n"..
"\n"..
"The block that was previously removed with the assembly tool and is to be placed again must be on the far left of the player inventory.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta3",
"",
"ta3_firebox",
"ta3_oilbox",
"ta3_boiler",
"ta3_turbine",
"ta3_generator",
"ta3_cooler",
"ta3_powerswitch",
"power_reduction",
"ta3_powercable",
"ta3_powerjunction",
"ta3_powerline",
"ta3_powerpole",
"ta3_powerpole4",
"ta3_powerpole2",
"ta3_powerswitch",
"ta3_powerswitchsmall",
"ta3_powerswitchbox",
"ta3_tinygenerator",
"ta3_akkublock",
"ta3_powerterminal",
"ta3_motor",
"",
"ta3_furnacefirebox",
"ta3_furnace",
"ta3_booster",
"",
"ta3_tank",
"ta3_pump",
"ta3_filler",
"ta3_pipe",
"ta3_pipe_wall_entry",
"ta3_valve",
"techage_ta3",
"ta3_oilexplorer",
"ta3_drillbox",
"ta3_pumpjack",
"ta3_drillbit",
"oiltank",
"",
"",
"",
"",
"",
"techage_ta31",
"",
"reboiler",
"ta3_logic",
"ta3_button",
"ta3_command_converter",
"ta3_flipflop",
"ta3_logic",
"ta3_repeater",
"ta3_sequencer",
"ta3_timer",
"ta3_terminal",
"ta3_colorlamp",
"ta3_doorblock",
"ta3_doorcontroller",
"ta3_doorcontroller",
"ta3_soundblock",
"ta3_mesecons_converter",
"ta3_nodedetector",
"ta3_detector",
"ta3_cartdetector",
"ta3_nodedetector",
"ta3_playerdetector",
"ta3_lightdetector",
"ta3_grinder",
"ta3_pusher",
"ta3_distributor",
"ta3_autocrafter",
"ta3_electronicfab",
"ta3_quarry",
"ta3_gravelsieve",
"ta3_gravelrinser",
"ta3_grinder",
"ta3_injector",
"",
"ta3_end_wrench",
"ta3_programmer",
"ta3_trowel",
"ta3_drill_pipe_wrench",
"ta3_screwdriver",
"techage:assembly_tool",
},
plans = {
"",
"coalpowerstation",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta3_furnace",
"",
"",
"",
"ta3_tank",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta3_loading",
"",
"",
"",
"ta3_distiller",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

942
doc/manual_ta3_pt-BR.lua Normal file
View File

@ -0,0 +1,942 @@
return {
titles = {
"1,TA3: Era do Petróleo",
"2,Usina Termelétrica a Carvão / Usina Termelétrica a Óleo",
"3,TA3 Fornalha(firebox) da estação de energia",
"3,TA3 Queimador de Óleo da Usina de Energia",
"3,TA3 Base / Topo da Caldeira",
"3,TA3 Turbina",
"3,TA3 Gerador",
"3,TA3 Cooler",
"2,Corrente elétrica",
"3,Importância dos sistemas de armazenamento",
"3,TA3 Cabo Elétrico",
"3,TA Caixa de Junção Elétrica",
"3,TA Linha de Energia",
"3,TA Poste de Energia",
"3,TA Topo do Poste de Energia",
"3,TA Topo do Poste de Energia 2",
"3,TA Interruptor de Energia",
"3,TA Interruptor de Energia Pequeno",
"3,TA Caixa de Interruptor de Energia",
"3,TA3 Pequeno Gerador de Energia",
"3,TA3 Bloco Acumulador",
"3,TA3 Terminal de Energia",
"3,TA3 Motor Elétrico",
"2,TA3 Forno Industrial",
"3,TA3 Forno - Queimador de Óleo",
"3,TA3 Forno - Parte Superior",
"3,TA3 Reforço",
"2,Líquidos",
"3,TA3 Tanque",
"3,TA3 Bomba",
"3,TA Liquid Filler",
"3,TA4 Tubos(pipe)",
"3,TA3 Tubos de parede (entre-blocos)",
"3,TA Válvula",
"2,Produção de Óleo",
"3,TA3 Explorador de petróleo",
"3,TA3 Caixa de perfuração de petróleo",
"3,TA3 Bomba de petróleo",
"3,TA3 Haste de perfuração",
"3,Tanque de petróleo",
"2,Transporte de Petróleo",
"3,Transporte de Petróleo por Vagões Tanque",
"3,Oil transportation with barrels over Minecarts",
"3,Transporte de Petróleo com Barris por Minecarts",
"3,Carrinho-tanque",
"3,Carrinho-baú",
"2,Processamento de Petróleo",
"3,Torre de Destilação",
"4,Refervedor(Reboiler)",
"2,Blocos Lógicos / de Comutação",
"3,TA3 Botão / Interruptor",
"3,TA3 Conversor de Comandos",
"3,TA3 Flip-Flop",
"3,Bloco Lógico TA3",
"3,TA3 Repetidor",
"3,TA3 Sequenciador",
"3,TA3 Temporizador",
"3,TA3 Terminal",
"3,Lâmpada Colorida TechAge",
"3,Blocos de Porta/Portão",
"3,TA3 Controlador de Porta",
"3,Controlador de Porta TA3 II",
"3,TA3 Bloco de Som",
"3,TA3 Conversor Mesecons",
"2,Detectores",
"3,TA3 Detector",
"3,TA3 Cart Detector",
"3,TA3 Node Detector",
"3,TA3 Detector de jogador(Player detector)",
"3,TA3 Detector de luz(Light detector)",
"2,Máquinas TA3",
"3,TA3 Pusher",
"3,TA3 Distributor",
"3,TA3 Autocrafter",
"3,TA3 Electronic Fab",
"3,TA3 Quarry",
"3,TA3 Gravel Sieve",
"3,TA3 Gravel Rinser",
"3,TA3 Grinder",
"3,TA3 Injetor",
"2,Ferramentas",
"3,Techage Info Tool",
"3,TechAge Programmer (Programador)",
"3,TechAge Trowel / Trowel",
"3,TA3 chave de cano",
"3,Techage Screwdriver",
"3,TechAge Assembly Tool",
},
texts = {
"Na TA3\\, é importante substituir as máquinas a vapor por máquinas mais potentes movidas a eletricidade.\n"..
"\n"..
"Para fazer isso\\, é necessário construir usinas termelétricas a carvão e geradores. Logo você perceberá que suas necessidades de eletricidade só podem ser atendidas com usinas movidas a óleo. Portanto\\, você parte em busca de petróleo. Torres de perfuração e bombas de petróleo ajudam a extrair o óleo. Ferrovias são usadas para transportar o óleo até as usinas.\n"..
"\n"..
"A era industrial está em seu auge.\n"..
"\n"..
"\n"..
"\n",
"A usina termelétrica a carvão é composta por vários blocos e deve ser montada conforme mostrado no plano à direita. São necessários os blocos Fornalha(Firebox) TA3\\, Topo da Caldeira TA3\\, Base da Caldeira TA3\\, Turbina TA3\\, Gerador TA3 e Resfriador TA3.\n"..
"\n"..
"A caldeira deve ser preenchida com água. Encha até 10 baldes de água na caldeira.\n"..
"A caixa de fogo deve ser preenchida com carvão ou carvão vegetal.\n"..
"Quando a água estiver quente\\, o gerador pode ser iniciado.\n"..
"\n"..
"Alternativamente\\, a usina pode ser equipada com um queimador de óleo e operada com óleo. O óleo pode ser reabastecido usando uma bomba e um tubo de óleo.\n"..
"\n"..
"A usina fornece uma saída de 80 ku.\n"..
"\n"..
"\n"..
"\n",
"Parte da usina de energia.\n"..
"A fornalha deve ser preenchida com carvão ou carvão vegetal. O tempo de queima depende da potência solicitada pela usina. Carvão queima por 20s e carvão vegetal por 60s em carga total. Proporcionalmente mais tempo em carga parcial (50% de carga = dobro do tempo).\n"..
"\n"..
"\n"..
"\n",
"Parte da usina de energia.\n"..
"\n"..
"O queimador de óleo pode ser preenchido com óleo cru\\, óleo combustível\\, nafta ou gasolina. O tempo de queima depende da potência solicitada pela usina. Em carga total\\, óleo cru queima por 15s\\, óleo combustível por 20s\\, nafta por 22s e gasolina por 25s.\n"..
"\n"..
"Proporcionalmente mais tempo em carga parcial (50% de carga = dobro do tempo).\n"..
"\n"..
"O queimador de óleo pode armazenar apenas 50 unidades de combustível. Recomenda-se\\, portanto\\, um tanque de óleo adicional e uma bomba de óleo.\n"..
"\n"..
"\n"..
"\n",
"Parte da usina de energia. Deve ser preenchida com água. Se não houver mais água ou a temperatura diminuir muito\\, a usina desliga.\n"..
"\n"..
"O consumo de água da caldeira TA3 é muito menor do que o da máquina a vapor devido ao circuito de vapor fechado.\n"..
"Com a máquina a vapor\\, parte da água é perdida como vapor a cada curso do pistão.\n"..
"\n"..
"\n"..
"\n",
"A turbina faz parte da usina de energia. Deve ser colocada ao lado do gerador e conectada à caldeira e ao resfriador por meio de tubos de vapor\\, conforme mostrado no plano.\n"..
"\n"..
"\n"..
"\n",
"O gerador é usado para gerar eletricidade. Deve ser conectado às máquinas por meio de cabos de energia e caixas de junção.\n"..
"\n"..
"\n"..
"\n",
"Usado para resfriar o vapor quente da turbina. Deve ser conectado à caldeira e à turbina por meio de tubos de vapor\\, conforme mostrado no plano.\n"..
"\n"..
"\n"..
"\n",
"Em TA3 (e TA4)\\, as máquinas são alimentadas por eletricidade. Para isso\\, máquinas\\, sistemas de armazenamento e geradores devem ser conectados com cabos de energia.\n"..
"TA3 possui 2 tipos de cabos de energia:\n"..
"\n"..
" - Cabos isolados (cabos de energia TA) para instalação local no chão ou em edifícios. Esses cabos podem ser ocultos na parede ou no chão (podem ser \"revestidos\" com a colher de pedreiro).\n"..
" - Linhas aéreas (linha de energia TA) para cabeamento externo em longas distâncias. Esses cabos são protegidos e não podem ser removidos por outros jogadores.\n"..
"\n"..
"Vários consumidores\\, sistemas de armazenamento e geradores podem ser operados juntos em uma rede de energia. Redes podem ser configuradas com a ajuda das caixas de junção.\n"..
"Se houver pouca eletricidade fornecida\\, os consumidores ficam sem energia.\n"..
"Nesse contexto\\, também é importante entender a funcionalidade dos blocos de Forceload\\, porque os geradores\\, por exemplo\\, só fornecem eletricidade quando o bloco de mapa correspondente está carregado. Isso pode ser imposto com um bloco de Forceload.\n"..
"\n"..
"Em TA4\\, também existe um cabo para o sistema solar.\n"..
"\n"..
"\n"..
"\n",
"Os sistemas de armazenamento na rede elétrica desempenham duas funções:\n"..
"\n"..
" - Lidar com picos de demanda: Todos os geradores sempre fornecem exatamente a quantidade de energia necessária. No entanto\\, se os consumidores forem ligados/desligados ou houver flutuações na demanda por outros motivos\\, os consumidores podem falhar por um curto período. Para evitar isso\\, deve sempre haver pelo menos um bloco de bateria em cada rede. Isso serve como um buffer e compensa essas flutuações na faixa de segundos.\n"..
" - Armazenar energia regenerativa: Solar e eólica não estão disponíveis 24 horas por dia. Para que o fornecimento de energia não falhe quando não há produção de eletricidade\\, um ou mais sistemas de armazenamento devem ser instalados na rede. Alternativamente\\, as lacunas também podem ser preenchidas com eletricidade de óleo/carvão.\n"..
"\n"..
"Um sistema de armazenamento indica sua capacidade em kud\\, ou seja\\, ku por dia. Por exemplo\\, um sistema de armazenamento com 100 kud fornece 100 ku por um dia de jogo\\, ou 10 ku por 10 dias de jogo.\n"..
"\n"..
"Todas as fontes de energia TA3/TA4 têm características de carregamento ajustáveis. Por padrão\\, isso é configurado para \"80% - 100%\". Isso significa que\\, quando o sistema de armazenamento estiver 80% cheio\\, a saída é reduzida cada vez mais até desligar completamente em 100%. Se eletricidade for necessária na rede\\, nunca se atingirá 100%\\, pois a potência do gerador em algum momento caiu para a demanda de eletricidade na rede e o sistema de armazenamento não está mais sendo carregado\\, mas apenas os consumidores estão sendo atendidos.\n"..
"\n"..
"Isso tem várias vantagens:\n"..
"\n"..
" - As características de carregamento são ajustáveis. Isso significa\\, por exemplo\\, que as fontes de energia de óleo/carvão podem ser reduzidas em 60% e as fontes de energia renovável apenas em 80%. Isso significa que o óleo/carvão só é queimado se não houver energia renovável suficiente disponível.\n"..
" - Várias fontes de energia podem ser operadas em paralelo e são carregadas quase uniformemente\\, porque todas as fontes de energia trabalham\\, por exemplo\\, até 80% da capacidade de carga do sistema de armazenamento em sua capacidade total e depois reduzem sua capacidade ao mesmo tempo.\n"..
" - Todos os sistemas de armazenamento em uma rede formam um grande buffer. A capacidade de carga e o nível de preenchimento de todo o sistema de armazenamento podem sempre ser lidos em percentagem em todos os sistemas de armazenamento\\, mas também no terminal de eletricidade.\n"..
"\n"..
" \n"..
"\n",
"Para fiação local no chão ou em construções.\n"..
"Ramos podem ser realizados usando caixas de junção. O comprimento máximo do cabo entre máquinas ou caixas de junção é de 1000 m. Um máximo de 1000 nós pode ser conectado em uma rede elétrica. Todos os blocos com conexão elétrica\\, incluindo caixas de junção\\, contam como nós.\n"..
"\n"..
"Como os cabos elétricos não são automaticamente protegidos\\, as linhas aéreas (TA power line) são recomendadas para distâncias mais longas.\n"..
"\n"..
"Os cabos elétricos podem ser rebocados com a colher de alvenaria para que fiquem ocultos na parede ou no chão. Todos os blocos de pedra\\, argila e outros blocos sem \"inteligência\" podem ser usados como material de reboco. A sujeira não funciona porque pode ser convertida em grama ou algo semelhante\\, o que destruiria a linha.\n"..
"\n"..
"Para rebocar\\, o cabo deve ser clicado com a colher de alvenaria. O material com o qual o cabo deve ser rebocado deve estar no canto mais à esquerda do inventário do jogador.\n"..
"Os cabos podem ser tornados visíveis novamente clicando no bloco com a colher de alvenaria.\n"..
"\n"..
"Além dos cabos\\, a caixa de junção TA e a caixa de interruptores de energia TA também podem ser rebocadas.\n"..
"\n"..
"\n"..
"\n",
"Com a caixa de junção\\, a eletricidade pode ser distribuída em até 6 direções. Caixas de junção também podem ser rebocadas (ocultas) com uma colher de alvenaria e tornadas visíveis novamente.\n"..
"\n"..
"\n"..
"\n",
"Com a linha de energia TA e os postes de eletricidade\\, é possível realizar linhas aéreas razoavelmente realistas. As cabeças dos postes também servem para proteger a linha de energia (proteção). Um poste deve ser colocado a cada 16 m ou menos. A proteção se aplica apenas à linha de energia e aos postes\\; no entanto\\, todos os outros blocos nesta área não estão protegidos.\n"..
"\n"..
"\n"..
"\n",
"Usado para construir postes de eletricidade. É protegido contra destruição pela cabeça do poste de eletricidade e só pode ser removido pelo proprietário.\n"..
"\n"..
"\n"..
"\n",
"Possui até quatro braços e permite assim a distribuição de eletricidade em até 6 direções.\n"..
"A cabeça do poste de eletricidade protege as linhas de energia e os postes dentro de um raio de 8 m.\n"..
"\n"..
"\n"..
"\n",
"Esta cabeça de poste de eletricidade tem dois braços fixos e é usada para as linhas aéreas. No entanto\\, também pode transmitir corrente para baixo e para cima.\n"..
"A cabeça do poste de eletricidade protege as linhas de energia e os postes dentro de um raio de 8 m.\n"..
"\n"..
"\n"..
"\n",
"O interruptor pode ser usado para ligar e desligar a energia. Para isso\\, o interruptor deve ser colocado em uma caixa de interruptor de energia. A caixa de interruptor de energia deve ser conectada ao cabo de energia em ambos os lados.\n"..
"\n"..
"\n"..
"\n",
"O interruptor pode ser usado para ligar e desligar a energia. Para isso\\, o interruptor deve ser colocado em uma caixa de interruptor de energia. A caixa de interruptor de energia deve ser conectada ao cabo de energia em ambos os lados.\n"..
"\n"..
"\n"..
"\n",
"Veja o interruptor de energia TA.\n"..
"\n"..
"\n"..
"\n",
"O pequeno gerador de energia funciona com gasolina e pode ser usado para consumidores pequenos com até 12 ku. A gasolina queima por 150s em carga total. Correspondentemente mais tempo em carga parcial (50% de carga = tempo duplo).\n"..
"\n"..
"O gerador de energia só pode armazenar 50 unidades de gasolina. Portanto\\, é aconselhável um tanque adicional e uma bomba.\n"..
"\n"..
"\n"..
"\n",
"O bloco acumulador (bateria recarregável) é usado para armazenar energia excedente e fornece automaticamente energia em caso de queda de energia (se disponível).\n"..
"Vários blocos de acumulador juntos formam um sistema de armazenamento de energia TA3. Cada bloco de acumulador possui um display para o estado de carga e para a carga armazenada.\n"..
"Os valores para toda a rede são sempre exibidos aqui. A carga armazenada é exibida em \"kud\" ou \"ku-dias\" (análogo a kWh). Assim\\, 5 kud correspondem\\, por exemplo\\, a 5 ku para um dia de jogo (20 minutos) ou 1 ku para 5 dias de jogo.\n"..
"\n"..
"Um bloco de acumulador tem 3\\,33 kud.\n"..
"\n"..
"\n"..
"\n",
"O terminal de energia deve ser conectado à rede elétrica. Ele exibe dados da rede elétrica.\n"..
"\n"..
"As informações mais importantes são exibidas na metade superior:\n"..
"\n"..
" - potência do gerador atual/máxima\n"..
" - consumo de energia atual de todos os consumidores\n"..
" - corrente de carga atual dentro/fora do sistema de armazenamento\n"..
" - Estado de carga atual do sistema de armazenamento em percentual\n"..
"\n"..
"O número de blocos da rede é exibido na metade inferior.\n"..
"\n"..
"Dados adicionais sobre os geradores e sistemas de armazenamento podem ser consultados através da guia \"console\".\n"..
"\n"..
"\n"..
"\n",
"O Motor Elétrico TA3 é necessário para operar as máquinas TA2 através da rede elétrica. O Motor Elétrico TA3 converte eletricidade em potência de eixo.\n"..
"Se o motor elétrico não for alimentado com energia suficiente\\, ele entra em um estado de falha e deve ser reativado com um clique direito.\n"..
"\n"..
"O motor elétrico consome no máximo 40 ku de eletricidade e fornece do outro lado no máximo 39 ku como potência de eixo. Portanto\\, ele consome um ku para a conversão.\n"..
"\n"..
"\n"..
"\n",
"O forno industrial TA3 serve como complemento aos fornos normais. Isso significa que todos os produtos podem ser fabricados com receitas de \"cozimento\"\\, mesmo em um forno industrial. No entanto\\, também existem receitas especiais que só podem ser feitas em um forno industrial.\n"..
"O forno industrial possui seu próprio menu para seleção de receitas. Dependendo dos produtos no inventário do forno industrial à esquerda\\, o produto de saída pode ser selecionado à direita.\n"..
"\n"..
"O forno industrial requer eletricidade (para o impulsionador) e óleo combustível/gasolina para o queimador. O forno industrial deve ser montado conforme mostrado no plano à direita.\n"..
"\n"..
"Veja também o aquecedor TA4.\n"..
"\n"..
"\n"..
"\n",
"Parte do forno industrial TA3.\n"..
"\n"..
"O queimador de óleo pode ser operado com óleo bruto\\, óleo combustível\\, nafta ou gasolina. O tempo de queima é de 64 s para óleo bruto\\, 80 s para óleo combustível\\, 90 s para nafta e 100 s para gasolina.\n"..
"\n"..
"O queimador de óleo pode armazenar apenas 50 unidades de combustível. Portanto\\, é aconselhável um tanque adicional e uma bomba.\n"..
"\n"..
"\n"..
"\n",
"Faz parte do forno industrial TA3. Consulte o forno industrial TA3.\n"..
"\n"..
"\n"..
"\n",
"Faz parte do forno industrial TA3. Consulte o forno industrial TA3.\n"..
"\n"..
"\n"..
"\n",
"Líquidos como água ou óleo só podem ser bombeados através de tubulações especiais e armazenados em tanques. Assim como com a água\\, existem recipientes (latas\\, barris) nos quais o líquido pode ser armazenado e transportado.\n"..
"\n"..
"Também é possível conectar vários tanques usando as tubulações amarelas e conectores. No entanto\\, os tanques devem ter o mesmo conteúdo e sempre deve haver pelo menos um tubo amarelo entre o tanque\\, a bomba e o tubo distribuidor.\n"..
"\n"..
"Por exemplo\\, não é possível conectar dois tanques diretamente a um tubo distribuidor.\n"..
"\n"..
"O enchimento de líquidos é usado para transferir líquidos de recipientes para tanques. O plano mostra como latas ou barris com líquidos são empurrados para um enchimento de líquidos através de empurradores. O recipiente é esvaziado no enchimento de líquidos e o líquido é conduzido para baixo no tanque.\n"..
"\n"..
"O enchimento de líquidos também pode ser colocado sob um tanque para esvaziar o tanque.\n"..
"\n"..
"\n"..
"\n",
"Líquidos podem ser armazenados em um tanque. Um tanque pode ser preenchido ou esvaziado usando uma bomba. Para fazer isso\\, a bomba deve ser conectada ao tanque por meio de um tubo (tubos amarelos).\n"..
"\n"..
"Um tanque também pode ser preenchido ou esvaziado manualmente clicando no tanque com um recipiente de líquido cheio ou vazio (barril\\, galão). Deve-se observar que os barris só podem ser completamente preenchidos ou esvaziados. Se\\, por exemplo\\, houver menos de 10 unidades no tanque\\, esse restante deve ser removido com galões ou esvaziado com uma bomba.\n"..
"\n"..
"Um tanque TA3 pode armazenar 1000 unidades ou 100 barris de líquido.\n"..
"\n"..
"\n"..
"\n",
"A bomba pode ser usada para bombear líquidos de tanques ou recipientes para outros tanques ou recipientes. A direção da bomba (seta) deve ser observada. As linhas amarelas e os conectores também permitem organizar vários tanques em cada lado da bomba. No entanto\\, os tanques devem ter o mesmo conteúdo.\n"..
"\n"..
"A bomba TA3 bombeia 4 unidades de líquido a cada dois segundos.\n"..
"\n"..
"Observação 1: A bomba não deve ser colocada diretamente ao lado do tanque. Deve sempre haver pelo menos um pedaço de tubo amarelo entre eles.\n"..
"\n"..
"\n"..
"\n",
"O liquid filler é usado para transferir líquidos entre recipientes e tanques.\n"..
"\n"..
" - Se o liquid filler for colocado sob um tanque e barris vazios forem colocados no liquid filler com um empurrador ou manualmente\\, o conteúdo do tanque é transferido para os barris e os barris podem ser removidos da saída\n"..
" - Se o liquid filler for colocado em cima de um tanque e se recipientes cheios forem colocados no liquid filler com um empurrador ou manualmente\\, o conteúdo é transferido para o tanque e os recipientes vazios podem ser removidos no lado de saída\n"..
"\n"..
"Deve-se observar que os barris só podem ser completamente cheios ou esvaziados. Se\\, por exemplo\\, houver menos de 10 unidades no tanque\\, este restante deve ser removido com recipientes ou bombeado vazio.\n"..
"\n"..
"\n"..
"\n",
"Os tubos amarelos são usados para a transmissão de gás e líquidos.\n"..
"O comprimento máximo do tubo é 100m.\n"..
"\n"..
"\n"..
"\n",
"Os blocos servem como aberturas de parede para os tubos\\, para que não fiquem buracos abertos.\n"..
"\n"..
"\n"..
"\n",
"Existe uma válvula para os tubos amarelos\\, que pode ser aberta e fechada com um clique do mouse.\n"..
"A válvula também pode ser controlada por comandos ligar/desligar.\n"..
"\n"..
"\n"..
"\n",
"Para alimentar seus geradores e fogões com óleo\\, você deve primeiro procurar óleo e construir uma torre de perfuração para extrair o óleo.\n"..
"Para isso\\, são utilizados o explorador de óleo TA3\\, a caixa de perfuração de óleo TA3 e o macaco de bomba de óleo TA3.\n"..
"\n"..
"\n"..
"\n",
"Você pode procurar petróleo com o explorador de petróleo. Para fazer isso\\, coloque o bloco no chão e clique com o botão direito para iniciar a busca. O explorador de petróleo pode ser usado tanto acima quanto abaixo do solo em todas as profundidades.\n"..
"A saída do chat mostra a profundidade até a qual o petróleo foi procurado e quanto petróleo foi encontrado.\n"..
"Você pode clicar várias vezes no bloco para procurar petróleo em áreas mais profundas. Os campos de petróleo variam em tamanho de 4.000 a 20.000 itens.\n"..
"\n"..
"Se a busca não der certo\\, você deve mover o bloco aproximadamente 16 m para frente.\n"..
"O explorador de petróleo sempre procura petróleo em todo o bloco do mapa e abaixo\\, no qual foi colocado. Uma nova busca no mesmo bloco do mapa (campo 16x16) portanto\\, não faz sentido.\n"..
"\n"..
"Se o petróleo for encontrado\\, a localização para a torre de perfuração é exibida. Você precisa erguer a torre de perfuração dentro da área mostrada\\, é melhor marcar o local com uma placa e proteger toda a área contra jogadores estrangeiros.\n"..
"\n"..
"Não desista de procurar petróleo muito rapidamente. Se tiver azar\\, pode levar muito tempo para encontrar um poço de petróleo.\n"..
"Também não faz sentido procurar em uma área que outro jogador já tenha procurado. A chance de encontrar petróleo é a mesma para todos os jogadores.\n"..
"\n"..
"O explorador de petróleo pode ser sempre usado para procurar petróleo.\n"..
"\n"..
"\n"..
"\n",
"A caixa de perfuração de petróleo deve ser colocada na posição indicada pelo explorador de petróleo. Perfurar petróleo em outro lugar não tem sentido.\n"..
"Se o botão na caixa de perfuração de petróleo for clicado\\, a torre de perfuração será erguida acima da caixa. Isso leva alguns segundos.\n"..
"A caixa de perfuração de petróleo tem 4 lados\\, em IN o tubo de perfuração deve ser entregue via pusher e em OUT o material de perfuração deve ser removido. A caixa de perfuração de petróleo deve ser alimentada com eletricidade por um dos outros dois lados.\n"..
"\n"..
"A caixa de perfuração de petróleo perfura até o campo de petróleo (1 metro em 16 s) e requer 16 ku de eletricidade.\n"..
"Depois que o campo de petróleo for alcançado\\, a torre de perfuração pode ser desmontada e a caixa removida.\n"..
"\n"..
"\n"..
"\n",
"A bomba de petróleo (pumpjack) deve ser colocada no lugar da caixa de perfuração de petróleo. A bomba de petróleo também requer eletricidade (16 ku) e fornece uma unidade de petróleo a cada 8 segundos. O petróleo deve ser coletado em um tanque. Para fazer isso\\, a bomba de petróleo deve ser conectada ao tanque por meio de tubos amarelos.\n"..
"Depois que todo o petróleo for bombeado para fora\\, a bomba de petróleo também pode ser removida.\n"..
"\n"..
"\n"..
"\n",
"A haste de perfuração é necessária para perfurar. Tantos itens de haste de perfuração são necessários quanto a profundidade especificada para o campo de petróleo. A haste de perfuração é inútil após a perfuração\\, mas também não pode ser desmontada e permanece no solo. No entanto\\, há uma ferramenta para remover os blocos de haste de perfuração (-> Ferramentas -> TA3 Alicate de haste de perfuração(drill pipe pliers)).\n"..
"\n"..
"\n"..
"\n",
"O tanque de petróleo é a versão grande do tanque TA3 (ver líquidos -> Tanque TA3).\n"..
"\n"..
"O tanque grande pode armazenar 4000 unidades de petróleo\\, mas também qualquer outro tipo de líquido.\n"..
"\n"..
"\n"..
"\n",
"",
"Os vagões tanque podem ser usados para transportar petróleo do poço de petróleo para a usina de processamento de petróleo. Um vagão tanque pode ser preenchido ou esvaziado diretamente usando bombas. Em ambos os casos\\, os tubos amarelos devem ser conectados ao vagão tanque de cima.\n"..
"\n"..
"Os seguintes passos são necessários:\n"..
"\n"..
" - Coloque o vagão tanque na frente do bloco para-choque da ferrovia. O bloco para-choque ainda não deve estar programado com um tempo para que o vagão tanque não comece automaticamente.\n"..
" - Conecte o vagão tanque à bomba usando tubos amarelos.\n"..
" - Ligue a bomba.\n"..
" - Programe o para-choque com um tempo (10 - 20s).\n"..
"\n"..
"Essa sequência deve ser observada em ambos os lados (encher / esvaziar).\n"..
"\n"..
"\n"..
"\n",
"Canisters and barrels can be loaded into the Minecarts. To do this\\, the oil must first be transferred to barrels. The oil barrels can be pushed directly into the Minecart with a pusher and tubes (see map). The empty barrels\\, which come back from the unloading station by Minecart\\, can be unloaded using a hopper\\, which is placed under the rail at the stop.\n"..
"\n"..
"It is not possible with the hopper to both *unload the empty barrels and load the full barrels at a stop*. The hopper immediately unloads the full barrels. It is therefore advisable to set up 2 stations on the loading and unloading side and then program the Minecart accordingly using a recording run.\n"..
"\n"..
"The plan shows how the oil can be pumped into a tank and filled into barrels via a liquid filler and loaded into Minecarts.\n"..
"\n"..
"For the Minecarts to start again automatically\\, the bumper blocks must be configured with the station name and waiting time. 5 s are sufficient for unloading. However\\, since the pushers always go into standby for several seconds when there is no Minecart\\, a time of 15 or more seconds must be entered for loading.\n"..
"\n"..
"\n"..
"\n",
"As latas e barris podem ser carregados nos Minecarts. Para fazer isso\\, o petróleo deve primeiro ser transferido para os barris. Os barris de petróleo podem ser empurrados diretamente para dentro do Minecart com um empurrador e tubos (veja o mapa). Os barris vazios\\, que retornam da estação de descarga por Minecart\\, podem ser descarregados usando um funil\\, que é colocado sob os trilhos na parada.\n"..
"\n"..
"Não é possível com o funil *descarregar os barris vazios e carregar os barris cheios em uma parada*. O funil descarrega imediatamente os barris cheios. Portanto\\, é aconselhável configurar 2 estações no lado de carregamento e descarregamento e\\, em seguida\\, programar o Minecart de acordo com uma corrida de gravação.\n"..
"\n"..
"O plano mostra como o petróleo pode ser bombeado para um tanque\\, preenchido em barris via um dispositivo de enchimento de líquidos e carregado em Minecarts.\n"..
"\n"..
"Para que os Minecarts reiniciem automaticamente\\, os blocos para-choque devem ser configurados com o nome da estação e o tempo de espera. 5 segundos são suficientes para descarregar. No entanto\\, como os empurradores sempre entram em espera por vários segundos quando não há Minecart\\, um tempo de 15 segundos ou mais deve ser inserido para carregar.\n"..
"\n"..
"\n"..
"\n",
"O carrinho-tanque é usado para transportar líquidos. Assim como os tanques\\, ele pode ser cheio com bombas ou esvaziado. Em ambos os casos\\, o tubo amarelo deve ser conectado ao caminhão-tanque de cima.\n"..
"\n"..
"Cabem 200 unidades no caminhão-tanque.\n"..
"\n"..
"\n"..
"\n",
"O carrinho-baú é usado para transportar itens. Assim como os baús\\, ele pode ser cheio ou esvaziado usando um empurrador.\n"..
"\n"..
"Cabem 4 pilhas no carrinho de baú.\n"..
"\n"..
"\n"..
"\n",
"O petróleo é uma mistura de substâncias e consiste em muitos componentes. O petróleo pode ser decomposto em seus principais componentes\\, como betume\\, óleo combustível\\, nafta\\, gasolina e gás propano\\, por meio de uma torre de destilação.\n"..
"O processamento adicional para produtos finais ocorre no reator químico.\n"..
"\n"..
"\n"..
"\n",
"A torre de destilação deve ser montada como no plano no canto superior direito.\n"..
"O betume é drenado pelo bloco de base. A saída está na parte de trás do bloco de base (observe a direção da seta).\n"..
"Os blocos \"torre de destilação\" com os números: 1\\, 2\\, 3\\, 2\\, 3\\, 2\\, 3\\, 4 são colocados sobre este bloco base.\n"..
"Óleo combustível\\, nafta e gasolina são drenados das aberturas de baixo para cima. O gás propano é capturado no topo.\n"..
"Todas as aberturas na torre devem ser conectadas a tanques.\n"..
"O reboiler deve ser conectado ao bloco \"torre de destilação 1\".\n"..
"\n"..
"O reboiler precisa de eletricidade (não mostrado no plano)!\n"..
"\n"..
"\n"..
"\n",
"O reboiler aquece o petróleo para aproximadamente 400 °C. Ele evapora em grande parte e é alimentado na torre de destilação para resfriamento.\n"..
"\n"..
"O reboiler requer 14 unidades de eletricidade e produz uma unidade de betume\\, óleo combustível\\, nafta\\, gasolina e propano a cada 16s.\n"..
"Para isso\\, o reboiler deve ser alimentado com petróleo por meio de uma bomba.\n"..
"\n"..
"\n"..
"\n",
"Além dos tubos para transporte de mercadorias\\, bem como os tubos de gás e energia\\, há também um nível de comunicação sem fio através do qual os blocos podem trocar dados entre si. Não é necessário desenhar linhas para isso\\, a conexão entre transmissor e receptor é feita apenas através do número do bloco.\n"..
"\n"..
"*Info:* Um número de bloco é um número único gerado pelo Techage quando muitos blocos do Techage são colocados. O número do bloco é usado para endereçamento durante a comunicação entre controladores e máquinas Techage. Todos os blocos que podem participar dessa comunicação mostram o número do bloco como texto de informações se você fixar o bloco com o cursor do mouse.\n"..
"\n"..
"Quais comandos um bloco suporta podem ser lidos e exibidos com a TechAge Info Tool (chave inglesa ou wrench).\n"..
"Os comandos mais simples suportados por quase todos os blocos são:\n"..
"\n"..
" - 'on' - para ligar o bloco / máquina / lâmpada\n"..
" - 'off' - para desligar o bloco / máquina / lâmpada\n"..
"\n"..
"Com a ajuda do Terminal TA3\\, esses comandos podem ser testados muito facilmente. Suponha que uma lâmpada de sinalização seja o número 123.\n"..
"Então com:\n"..
"\n"..
" cmd 123 on\n"..
"\n"..
"a lâmpada pode ser ligada e com:\n"..
"\n"..
" cmd 123 off\n"..
"\n"..
"a lâmpada pode ser desligada novamente. Esses comandos devem ser inseridos no campo de entrada do terminal TA3.\n"..
"\n"..
"Comandos como 'on' e 'off' são enviados ao destinatário sem que uma resposta seja enviada de volta. Portanto\\, esses comandos podem ser enviados para vários destinatários ao mesmo tempo\\, por exemplo\\, com um botão de pressão / interruptor\\, se vários números forem inseridos no campo de entrada.\n"..
"\n"..
"Um comando como 'state' solicita o status de um bloco. O bloco então envia seu status de volta. Esse tipo de comando confirmado só pode ser enviado para um destinatário de cada vez.\n"..
"Esse comando também pode ser testado com o terminal TA3 em um empurrador\\, por exemplo:\n"..
"\n"..
" cmd 123 state\n"..
"\n"..
"As respostas possíveis do empurrador são:\n"..
"\n"..
" - 'running' -> Estou funcionando\n"..
" - 'stopped' -> desligado\n"..
" - 'standby' -> nada a fazer porque o inventário da fonte está vazio\n"..
" - 'blocked' -> não pode fazer nada porque o inventário de destino está cheio\n"..
"\n"..
"Esse status e outras informações também são exibidos quando a chave inglesa(wrench) é clicada no bloco.\n"..
"\n"..
"\n"..
"\n",
"O botão/interruptor envia comandos 'on' / 'off' para os blocos que foram configurados através dos números.\n"..
"O botão/interruptor pode ser configurado como um botão ou um interruptor. Se for configurado como um botão\\, o tempo entre os comandos 'on' e 'off' pode ser definido. Com o modo de operação \"no botão\"\\, apenas um comando 'on' e nenhum comando 'off' é enviado.\n"..
"\n"..
"A caixa de seleção \"público\" pode ser usada para definir se o botão pode ser usado por todos (marcado) ou apenas pelo próprio proprietário (não marcado).\n"..
"\n"..
"Nota: Com o programador\\, os números dos blocos podem ser facilmente coletados e configurados.\n"..
"\n"..
"\n"..
"\n",
"Com o conversor de comandos TA3\\, os comandos 'on' / 'off' podem ser convertidos em outros comandos\\, e o encaminhamento pode ser impedido ou atrasado.\n"..
"Deve-se inserir o número do bloco de destino ou os números dos blocos de destino\\, os comandos a serem enviados e os tempos de atraso em segundos. Se nenhum comando for inserido\\, nada será enviado.\n"..
"\n"..
"Os números também podem ser programados usando o programador Techage(programmer).\n"..
"\n"..
"\n"..
"\n",
"O flip-flop TA3 muda de estado a cada comando 'on' recebido. Os comandos 'off' recebidos são ignorados. Dependendo da alteração de status\\, os comandos 'on' / 'off' são enviados alternadamente. Deve-se inserir o número do bloco de destino ou os números dos blocos de destino. Os números também podem ser programados usando o programador Techage.\n"..
"\n"..
"Por exemplo\\, lâmpadas podem ser ligadas e desligadas com a ajuda de botões.\n"..
"\n"..
"\n"..
"\n",
"O bloco lógico TA3 pode ser programado de forma que um ou mais comandos de entrada estejam vinculados a um comando de saída e sejam enviados. Este bloco pode\\, portanto\\, substituir vários elementos lógicos\\, como AND\\, OR\\, NOT\\, XOR\\, etc.\n"..
"Os comandos de entrada para o bloco lógico são comandos 'ligar' / 'desligar'.\n"..
"Os comandos de entrada são referenciados pelo número\\, por exemplo\\, '1234' para o comando do remetente com o número 1234.\n"..
"O mesmo se aplica aos comandos de saída.\n"..
"\n"..
"Uma regra é estruturada da seguinte forma:\n"..
"\n"..
" <output> = on/off if <expressão-de-entrada> is true\n"..
"\n"..
"'<output>' é o número do bloco para o qual o comando deve ser enviado.\n"..
"'<expressão-de-entrada>' é uma expressão booleana onde os números de entrada são avaliados.\n"..
"\n"..
"*Exemplos para a expressão de entrada*\n"..
"\n"..
"Negar sinal (NOT):\n"..
"\n"..
" 1234 == off\n"..
"\n"..
"AND lógico:\n"..
"\n"..
" 1234 == on e 2345 == on\n"..
"\n"..
"OR lógico:\n"..
"\n"..
" 1234 == ligar ou 2345 == ligar\n"..
"\n"..
"Os seguintes operadores são permitidos: 'and' 'or' 'on' 'off' 'me' '==' '~=' '(' ')'\n"..
"\n"..
"Se a expressão for verdadeira\\, um comando é enviado para o bloco com o número '<output>'.\n"..
"Até quatro regras podem ser definidas\\, sendo que todas as regras são sempre verificadas quando um comando é recebido.\n"..
"O tempo interno de processamento para todos os comandos é de 100 ms.\n"..
"\n"..
"Seu próprio número de nó pode ser referenciado usando a palavra-chave 'me'. Isso permite que o bloco envie a si mesmo um comando (função flip-flop).\n"..
"\n"..
"O tempo de bloqueio define uma pausa após um comando\\, durante a qual o bloco lógico não aceita mais comandos externos. Comandos recebidos durante o período de bloqueio são descartados. O tempo de bloqueio pode ser definido em segundos.\n"..
"\n"..
"\n"..
"\n",
"O repetidor envia o sinal recebido para todos os números configurados.\n"..
"Isso pode fazer sentido\\, por exemplo\\, se você quiser controlar muitos blocos ao mesmo tempo. O repetidor pode ser configurado com o programador\\, o que não é possível com todos os blocos.\n"..
"\n"..
"\n"..
"\n",
"O sequenciador pode enviar uma série de comandos 'on' / 'off'\\, em que o intervalo entre os comandos deve ser especificado em segundos. Você pode usá-lo para fazer uma lâmpada piscar\\, por exemplo.\n"..
"Até 8 comandos podem ser configurados\\, cada um com número de bloco de destino e aguardando o próximo comando.\n"..
"O sequenciador repete os comandos indefinidamente quando \"Run endless\" está ativado.\n"..
"Se nada for selecionado\\, apenas o tempo especificado em segundos é aguardado.\n"..
"\n"..
"\n"..
"\n",
"O temporizador pode enviar comandos controlados pelo tempo. O horário\\, o(s) número(s) de destino e o comando em si podem ser especificados para cada linha de comando. Isso significa que as lâmpadas podem ser ligadas à noite e desligadas pela manhã.\n"..
"\n"..
"\n"..
"\n",
"O terminal é usado principalmente para testar a interface de comando de outros blocos (veja \"Blocos lógicos / de comutação\").\n"..
"Você também pode atribuir comandos a teclas e usar o terminal de maneira produtiva.\n"..
"\n"..
" set <número-do-botão> <texto-do-botão> <comando>\n"..
"\n"..
"Com 'set 1 ON cmd 123 on'\\, por exemplo\\, a tecla do usuário 1 pode ser programada com o comando 'cmd 123 on'. Se a tecla for pressionada\\, o comando é enviado e a resposta é exibida na tela.\n"..
"\n"..
"O terminal possui os seguintes comandos locais:\n"..
"\n"..
" - 'clear' limpa a tela\n"..
" - 'help' exibe uma página de ajuda\n"..
" - 'pub' alterna para o modo público\n"..
" - 'priv' alterna para o modo privado\n"..
"\n"..
"No modo privado\\, o terminal só pode ser usado por jogadores que podem construir neste local\\, ou seja\\, que têm direitos de proteção.\n"..
"\n"..
"No modo público\\, todos os jogadores podem usar as teclas preconfiguradas.\n"..
"\n"..
"\n"..
"\n",
"A lâmpada de sinalização pode ser ligada ou desligada com o comando 'on' / 'off'. Esta lâmpada não precisa de eletricidade e pode ser colorida com a ferramenta de aerografia do mod \"Dyes Unificados\" e via comandos Lua/Beduino.\n"..
"\n"..
"Com o comando de chat '/ta_color'\\, a paleta de cores com os valores para os comandos Lua/Beduino é exibida e com '/ta_send color <num>' a cor pode ser alterada.\n"..
"\n"..
"\n"..
"\n",
"Com esses blocos\\, você pode criar portas e portões que podem ser abertos por meio de comandos (blocos desaparecem) e fechados novamente. Um controlador de porta é necessário para cada portão ou porta.\n"..
"\n"..
"A aparência dos blocos pode ser ajustada por meio do menu de blocos.\n"..
"Isso permite a criação de portas secretas que só se abrem para certos jogadores (com a ajuda do detector de jogadores).\n"..
"\n"..
"\n"..
"\n",
"O controlador de porta é usado para controlar os blocos de porta/portão TA3. Com o controlador de porta\\, os números dos blocos de porta/portão devem ser inseridos. Se um comando 'on' / 'off' for enviado para o controlador de porta\\, isso abre/fecha a porta ou portão.\n"..
"\n"..
"\n"..
"\n",
"O Controlador de Porta II pode remover e definir todos os tipos de blocos. Para ensinar ao Controlador de Porta II\\, o botão \"Record\" deve ser pressionado. Em seguida\\, todos os blocos que devem fazer parte da porta/portão devem ser clicados. Depois\\, o botão \"Done\" deve ser pressionado. Até 16 blocos podem ser selecionados. Os blocos removidos são salvos no inventário do controlador. A função do controlador pode ser testada manualmente usando os botões \"Remove\" ou \"Set\". Se um comando 'on' /'off' for enviado para o Controlador de Porta II\\, ele remove ou define os blocos também.\n"..
"\n"..
"Com '$send_cmnd(número_do_nó\\, \"exchange\"\\, 2)' blocos individuais podem ser definidos\\, removidos ou substituídos por outros blocos do inventário.\n"..
"\n"..
"Com '$send_cmnd(número_do_nó\\, \"set\"\\, 2)' um bloco do inventário pode ser definido explicitamente\\, desde que o slot do inventário não esteja vazio.\n"..
"\n"..
"Um bloco pode ser removido novamente com '$send_cmnd(número_do_nó\\, \"dig\"\\, 2)' se o slot do inventário estiver vazio.\n"..
"\n"..
"O nome do bloco definido é retornado com '$send_cmnd(número_do_nó\\, \"get\"\\, 2)'.\n"..
"\n"..
"O número do slot do inventário (1 .. 16) deve ser passado como carga útil em todos os três casos.\n"..
"\n"..
"Isso também pode ser usado para simular escadas extensíveis e coisas do tipo.\n"..
"\n"..
"\n"..
"\n",
"Diferentes sons podem ser reproduzidos com o bloco de som. Todos os sons dos Mods Techage\\, Signs Bot\\, Hyperloop\\, Unified Inventory\\, TA4 Jetpack e Minetest Game estão disponíveis.\n"..
"\n"..
"Os sons podem ser selecionados e reproduzidos pelo menu e via comando.\n"..
"\n"..
" - Comando 'on' para reproduzir um som\n"..
" - Comando 'sound <índice>' para selecionar um som via o índice\n"..
" - Comando 'gain <volume>' para ajustar o volume via o valor '<volume>' (1 a 5).\n"..
"\n"..
"\n"..
"\n",
"O conversor Mesecons é utilizado para converter comandos de ligar/desligar do Techage em sinais Mesecons e vice-versa.\n"..
"Para fazer isso\\, um ou mais números de nó devem ser inseridos e o conversor deve ser conectado a blocos Mesecons por meio de cabos Mesecons. O conversor Mesecons também pode ser configurado com o programador.\n"..
"O conversor Mesecons aceita até 5 comandos por segundo\\; ele se desativa em cargas mais altas.\n"..
"\n"..
"*Este nó só existe se o mod mesecons estiver ativo!*\n"..
"\n"..
"\n"..
"\n",
"Os detectores escaneiam o ambiente e enviam um comando 'on' quando a busca é reconhecida.\n"..
"\n"..
"\n"..
"\n",
"O detector é um bloco de tubo especial que detecta quando itens passam pelo tubo. Para fazer isso\\, ele deve ser conectado a tubos dos dois lados. Se os itens forem empurrados para o detector com um empurrador(pusher)\\, eles são passados automaticamente.\n"..
"Ele envia um comando 'on' quando um item é reconhecido\\, seguido por um 'off' um segundo depois.\n"..
"Em seguida\\, outros comandos são bloqueados por 8 segundos.\n"..
"O tempo de espera e os itens que devem acionar um comando podem ser configurados usando o menu de chave inglesa(wrench).\n"..
"\n"..
"\n"..
"\n",
"O detector de carrinho envia um comando 'on' se reconhecer um carrinho (Minecart) diretamente na frente dele. Além disso\\, o detector também pode reiniciar o carrinho quando recebe um comando 'on'.\n"..
"\n"..
"O detector também pode ser programado com seu próprio número. Nesse caso\\, ele empurra todos os vagões que param perto dele (um bloco em todas as direções).\n"..
"\n"..
"\n"..
"\n",
"O detector de nó envia um comando 'on' se detectar que nós (blocos) aparecem ou desaparecem na frente dele\\, mas deve ser configurado de acordo. Após retornar o detector ao estado padrão (bloco cinza)\\, um comando 'off' é enviado. Blocos válidos são todos os tipos de blocos e plantas\\, mas não animais ou jogadores. O alcance do sensor é de 3 blocos por metro na direção da seta.\n"..
"\n"..
"\n"..
"\n",
"O detector de jogador envia um comando 'on' se detectar um jogador dentro de 4m do bloco. Se o jogador sair da área\\, um comando 'off' é enviado.\n"..
"Se a pesquisa deve ser limitada a jogadores específicos\\, esses nomes de jogador também podem ser inseridos.\n"..
"\n"..
"\n"..
"\n",
"O detector de luz envia um comando 'on' se o nível de luz do bloco acima exceder um certo nível\\, que pode ser definido através do menu de clique direito.\n"..
"Se você tiver um Controlador Lua TA4\\, pode obter o nível exato de luz com $get_cmd(num\\, 'light_level')\n"..
"\n"..
"\n"..
"\n",
"TA3 possui as mesmas máquinas que o TA2\\, apenas estas são mais poderosas e requerem eletricidade em vez de movimento por eixo.\n"..
"Portanto\\, abaixo são fornecidos apenas os dados técnicos diferentes.\n"..
"\n"..
"\n"..
"\n",
"A função corresponde à do TA2.\n"..
"A capacidade de processamento é de 6 itens a cada 2 segundos.\n"..
"\n"..
"\n"..
"\n",
"A função do Distribuidor TA3 corresponde à do TA2.\n"..
"A capacidade de processamento é de 12 itens a cada 4 segundos.\n"..
"\n"..
"\n"..
"\n",
"A função corresponde à do TA2.\n"..
"A capacidade de processamento é de 2 itens a cada 4 segundos. O autocrafter requer 6 ku de eletricidade.\n"..
"\n"..
"\n"..
"\n",
"A função corresponde à do TA2\\, apenas os chips WLAN do TA4 são produzidos aqui.\n"..
"A capacidade de processamento é de um chip a cada 6 segundos. O bloco requer 12 ku de eletricidade para isso.\n"..
"\n"..
"\n"..
"\n",
"A função corresponde à do TA2.\n"..
"A profundidade máxima é de 40 metros. A pedreira requer 12 ku de eletricidade.\n"..
"\n"..
"\n"..
"\n",
"A função corresponde à do TA2.\n"..
"A capacidade de processamento é de 2 itens a cada 4 segundos. O bloco requer 4 ku de eletricidade.\n"..
"\n"..
"\n"..
"\n",
"A função corresponde à do TA2.\n"..
"A probabilidade também é a mesma que a do TA2. O bloco também requer 3 ku de eletricidade.\n"..
"Mas\\, ao contrário do TA2\\, o status do bloco TA3 pode ser lido (controlador)\n"..
"\n"..
"\n"..
"\n",
"A função corresponde à do TA2.\n"..
"A capacidade de processamento é de 2 itens a cada 4 segundos. O bloco requer 6 ku de eletricidade.\n"..
"\n"..
"\n"..
"\n",
"O injetor é um TA3 pusher com propriedades especiais. Ele possui um menu para configuração. Até 8 itens podem ser configurados aqui. Ele apenas pega esses itens de um baú para passá-los para as máquinas com receitas (autocrafter\\, forno industrial e electronic fab).\n"..
"\n"..
"Ao passar\\, apenas uma posição no inventário é usada na máquina de destino. Se\\, por exemplo\\, apenas as três primeiras entradas estiverem configuradas no injetor\\, apenas as três primeiras posições de armazenamento no inventário da máquina serão usadas. Isso evita o transbordamento no inventário da máquina.\n"..
"\n"..
"O injetor também pode ser alternado para o \"modo pull\". Então ele apenas retira itens do baú das posições que estão definidas na configuração do injetor. Nesse caso\\, o tipo e a posição do item devem corresponder. Isso permite esvaziar entradas específicas do inventário de um baú.\n"..
"\n"..
"A capacidade de processamento é de até 8 vezes um item a cada 4 segundos.\n"..
"\n"..
"\n"..
"\n",
"",
"O Techage Info Tool (chave inglesa de ponta aberta) possui várias funções. Ele mostra a hora\\, posição\\, temperatura e bioma quando um bloco desconhecido é clicado.\n"..
"Se você clicar em um bloco TechAge com interface de comando\\, todos os dados disponíveis serão mostrados (consulte também \"Blocos lógicos / de comutação\").\n"..
"\n"..
"Com Shift + clique direito\\, um menu estendido pode ser aberto para alguns blocos. Dependendo do bloco\\, dados adicionais podem ser chamados ou configurações especiais podem ser feitas aqui. No caso de um gerador\\, por exemplo\\, a curva de carga/desligamento pode ser programada.\n"..
"\n"..
"\n"..
"\n",
"Com o programador\\, números de bloco podem ser coletados de vários blocos com um clique direito e gravados em um bloco como um botão / interruptor com um clique esquerdo.\n"..
"Se você clicar no ar\\, a memória interna é apagada.\n"..
"\n"..
"\n"..
"\n",
"A colher de pedreiro é usada para revestir cabos de energia. Veja também \"Cabo de energia TA\".\n"..
"\n"..
"\n"..
"\n",
"Esta ferramenta pode ser usada para remover blocos de tubo se\\, por exemplo\\, um túnel precisar passar por lá.\n"..
"\n"..
"\n"..
"\n",
"A chave de fenda Techage serve como substituto da chave de fenda normal. Ela possui as seguintes funções:\n"..
"\n"..
" - Clique esquerdo: girar o bloco para a esquerda\n"..
" - Clique direito: girar a face visível do bloco para cima\n"..
" - Shift + clique esquerdo: salvar o alinhamento do bloco clicado\n"..
" - Shift + clique direito: aplicar o alinhamento salvo ao bloco clicado\n"..
"\n"..
" \n"..
"\n",
"A TechAge Assembly Tool é usada para remover e reposicionar blocos Techage sem que esses blocos percam seu número de bloco ou recebam um novo número ao serem configurados. Isso é útil\\, por exemplo\\, para pedreiras\\, já que muitas vezes precisam ser movidas.\n"..
"\n"..
" - Botão esquerdo: remover um bloco\n"..
" - Botão direito: configurar um bloco\n"..
"\n"..
"O bloco que foi removido anteriormente com a ferramenta de montagem e que será colocado novamente deve estar no extremo esquerdo do inventário do jogador.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta3",
"",
"ta3_firebox",
"ta3_oilbox",
"ta3_boiler",
"ta3_turbine",
"ta3_generator",
"ta3_cooler",
"ta3_powerswitch",
"power_reduction",
"ta3_powercable",
"ta3_powerjunction",
"ta3_powerline",
"ta3_powerpole",
"ta3_powerpole4",
"ta3_powerpole2",
"ta3_powerswitch",
"ta3_powerswitchsmall",
"ta3_powerswitchbox",
"ta3_tinygenerator",
"ta3_akkublock",
"ta3_powerterminal",
"ta3_motor",
"",
"ta3_furnacefirebox",
"ta3_furnace",
"ta3_booster",
"",
"ta3_tank",
"ta3_pump",
"ta3_filler",
"ta3_pipe",
"ta3_pipe_wall_entry",
"ta3_valve",
"techage_ta3",
"ta3_oilexplorer",
"ta3_drillbox",
"ta3_pumpjack",
"ta3_drillbit",
"oiltank",
"",
"tank_cart",
"",
"",
"tank_cart",
"chest_cart",
"techage_ta31",
"",
"reboiler",
"ta3_logic",
"ta3_button",
"ta3_command_converter",
"ta3_flipflop",
"ta3_logic",
"ta3_repeater",
"ta3_sequencer",
"ta3_timer",
"ta3_terminal",
"ta3_colorlamp",
"ta3_doorblock",
"ta3_doorcontroller",
"ta3_doorcontroller",
"ta3_soundblock",
"ta3_mesecons_converter",
"ta3_nodedetector",
"ta3_detector",
"ta3_cartdetector",
"ta3_nodedetector",
"ta3_playerdetector",
"ta3_lightdetector",
"ta3_grinder",
"ta3_pusher",
"ta3_distributor",
"ta3_autocrafter",
"ta3_electronicfab",
"ta3_quarry",
"ta3_gravelsieve",
"ta3_gravelrinser",
"ta3_grinder",
"ta3_injector",
"",
"ta3_end_wrench",
"ta3_programmer",
"ta3_trowel",
"ta3_drill_pipe_wrench",
"ta3_screwdriver",
"techage:assembly_tool",
},
plans = {
"",
"coalpowerstation",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta3_furnace",
"",
"",
"",
"ta3_tank",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta3_loading",
"ta3_loading",
"",
"",
"",
"ta3_distiller",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
}
}

1052
doc/manual_ta4_DE.lua Normal file

File diff suppressed because it is too large Load Diff

1054
doc/manual_ta4_EN.lua Normal file

File diff suppressed because it is too large Load Diff

1054
doc/manual_ta4_pt-BR.lua Normal file

File diff suppressed because it is too large Load Diff

219
doc/manual_ta5_DE.lua Normal file
View File

@ -0,0 +1,219 @@
return {
titles = {
"1,TA5: Zukunft",
"2,Energiequellen",
"3,TA5 Fusionsreaktor",
"4,TA5 Fusionreaktor Magnet",
"4,TA5 Pumpe",
"4,TA5 Wärmetauscher",
"4,TA5 Fusionreaktor Controller",
"4,TA5 Fusionreaktor Hülle",
"4,TA5 Fusionreaktor Kern",
"2,Energiespeicher",
"3,TA5 Hybrid-Speicher (geplant)",
"2,Logik Blöcke",
"2,Transport und Verkehr",
"3,TA5 Flug Controller",
"3,TA5 Hyperloop Kiste / TA5 Hyperloop Chest",
"3,TA5 Hyperloop Tank / TA5 Hyperloop Tank",
"3,TA5-Raumgleiter (geplant)",
"2,Teleport Blöcke",
"3,TA5 Teleport Block Gegenstände / TA5 Teleport Block Items",
"3,TA5 Teleport Block Flüssigkeiten / TA5 Teleport Block Liquids",
"3,Hyperloop Teleport Blöcke (geplant)",
"2,Weitere TA5 Blöcke/Items",
"3,TA5 Container (geplant)",
"3,TA5 KI Chip / TA5 AI Chip",
"3,TA5 KI Chip II / TA5 AI Chip II",
},
texts = {
"Maschinen zur Überwindung von Raum und Zeit\\, neue Energiequellen und andere Errungenschaften prägen dein Leben. \n"..
"\n"..
"Für die Herstellung und Nutzung von TA5 Maschinen und Blöcken sind Erfahrungspunkte (experience points) notwendig. Diese können nur über den Teilchenbeschleuniger aus TA4 erarbeitet werden.\n"..
"\n"..
"\n"..
"\n",
"",
"Kernfusion bedeutet das Verschmelzen zweier Atomkerne. Dabei können\\, je nach Reaktion\\, große Mengen von Energie freigesetzt werden. Kernfusionen\\, bei denen Energie frei wird\\, laufen in Form von Kettenreaktionen ab. Sie sind die Quelle der Energie der Sterne\\, zum Beispiel auch unserer Sonne. Ein Fusionsreaktor wandelt die Energie\\, die bei einer kontrollierten Kernfusion frei wird\\, in elektrischen Strom um.\n"..
"\n"..
"*Wie funktionieren ein Fusionsreaktor?*\n"..
"\n"..
"Ein Fusionsreaktor funktioniert nach dem klassischen Prinzip eines Wärmekraftwerks: Wasser wird erhitzt und treibt eine Dampfturbine an\\, deren Bewegungsenergie von einem Generator in Strom gewandelt wird.\n"..
"\n"..
"Ein Fusionskraftwerk benötigt zunächst eine hohe Menge an Energie\\, da ein Plasma erzeugt werden muss. „Plasma“ nennt man den vierten Zustand von Stoffen\\, nach fest\\, flüssig und gasförmig. Dafür wird viel Strom benötigt. Erst durch diese extreme Energiekonzentration zündet die Fusionsreaktion und mit der abgegebenen Wärme wird über den Wärmetauscher Strom erzeugt. Der Generator liefert dann 800 ku an Strom.\n"..
"\n"..
"Der Plan rechts zeigt einen Schnitt durch den Fusionsreaktor.\n"..
"\n"..
"Für den Betrieb des Fusionsreaktors werden 60 Erfahrungspunkte benötigt. Der Fusionsreaktur muss komplett in einem Forceload Block Bereich aufgebaut werden.\n"..
"\n"..
"\n"..
"\n",
"Für den Aufbau des Fusionsreaktor werden insgesamt 60 TA5 Fusionreaktor Magnete benötigt. Diese bilden den Ring\\, in dem sich das Plasma bildet. Der TA5 Fusionsreaktor Magnete benötigt Strom und hat zwei Anschlüsse für die Kühlung.\n"..
"\n"..
"Es gibt zwei Typen von Magneten\\, so dass auch alle Seiten des Magnets\\, die zum Plasmaring zeigen\\, mit einem Hitzeschild geschützt werden können.\n"..
"\n"..
"Bei den Eckmagneten auf der Innenseite des Rings ist jeweils eine Anschlussseite verdeckt (Strom oder Kühlung) und kann daher nicht angeschlossen werden. Dies ist technisch nicht machbar und hat daher keinen Einfluß auf die Funktion des Fusionsreaktor. \n"..
"\n"..
"\n"..
"\n",
"Die Pumpe wird benötigt\\, um den Kühlkreislauf mit Isobutan zu füllen. Es werden ca. 350 Einheiten Isobutan benötigt.\n"..
"\n"..
"Hinweis: Die TA5 Pumpe kann nur zum Füllen des Kühlkreislaufs genutzt werden\\, ein Abpumpen des Kühlmittels ist nicht möglich. Daher sollte die Pumpe erst eingeschaltet werden\\, wenn die Magnete korrekt platziert und alle Strom- und Kühlleitungen angeschlossen sind.\n"..
"\n"..
"\n"..
"\n",
"Der TA5 Wärmetauscher wird benötigt\\, um die im Fusionsreaktor erzeugte Hitze zuerst in Dampf und dann in Strom umzuwandeln. Der Wärmetauscher selbst benötigt dazu 5 ku Strom. Der Aufbau gleicht dem Wärmetauscher des Energiespeichers aus TA4.\n"..
"\n"..
"Hinweis: Der TA5 Wärmetauscher hat zwei Anschlüsse (blau und grün) für den Kühlkreislauf. Über die grünen und blauen Röhren müssen der Wärmetauscher und alle Magnete zu einem Kühlkreislauf verbunden werden.\n"..
"\n"..
"Über den Start-Button des Wärmetauschers kann der Kühlkreislauf auf Vollständigkeit geprüft werden\\, auch wenn noch kein Kühlmittel eingefüllt wurde.\n"..
"\n"..
"\n"..
"\n",
"Über den TA5 Fusionreaktor Controller wird der Fusionreaktors eingeschaltet. Dabei muss zuerst die Kühlung/Wärmetauscher und dann der Controller eingeschaltet werden. Es dauert ca. 2 min\\, bis der Reaktor in Gang kommt und Strom liefert. Der Fusionreaktor und damit der Controller benötigt 400 ku an Strom\\, um das Plasma aufrecht zu erhalten.\n"..
"\n"..
"\n"..
"\n",
"Der komplette Reaktor muss mit einer Hülle umgeben werden\\, die den enormen Druck\\, den die Magnete auf das Plasma ausüben\\, abfängt und die Umgebung vor Strahlung schützt. Ohne diese Hülle kann der Reaktor nicht gestartet werden. Mit der TechAge Kelle können auch Stromkabel und Kühlleitungen des Fusionreaktors in die Hülle integriert werden.\n"..
"\n"..
"\n"..
"\n",
"Der Kern muss in der Mitte des Reaktors sitzen. Siehe Abbildung unter \"TA5 Fusionsreaktor\". Auch hierfür wird die TechAge Kelle benötigt.\n"..
"\n"..
"\n"..
"\n",
"",
"",
"",
"",
"Der TA5 Flug Controller ist ähnlich zum TA4 Move Controller. Im Gegensatz zum TA4 Move Controller können hier mehrere Bewegungen zu einer Flugstrecke kombiniert werden. Diese Flugstrecke kann im Eingabefeld über mehrere x\\,y\\,z Angaben definiert werden (eine Bewegung pro Zeile). Über \"Speichern\" wird die Flugstrecke geprüft und gespeichert. Bei einem Fehler wird eine Fehlermeldung ausgegeben.\n"..
"\n"..
"Mit der Taste \"Test\" wird die Flugstrecke mit den absoluten Koordinaten zur Überprüfung im Chat ausgegeben.\n"..
"\n"..
"Die maximale Distanz für die gesammte Flugstrecke beträgt 1500 m. Es können bis zu 32 Blöcke antrainiert werden.\n"..
"\n"..
"Die Nutzung des TA5 Flug Controllers benötigt 40 Erfahrungspunkte.\n"..
"\n"..
"*Teleport Mode*\n"..
"\n"..
"Wird der 'Teleport Mode' aktiviert (auf 'enable' gesetzt)\\, kann ein Spieler auch ohne Blöcke bewegt werden. Dazu muss die Startposition über die Taste \"Aufzeichnen\" konfiguriert werden. Es kann hier nur eine Position konfiguriert werden. Das Spieler\\, der bewegt werden soll\\, muss dazu auf dieser Position stehen. \n"..
"\n"..
"\n"..
"\n",
"Die TA5 Hyperloop Kiste erlaubt den Transport von Gegenständen über ein Hyperloop Netzwerk.\n"..
"\n"..
"Die TA5 Hyperloop Kiste muss man dazu auf eine Hyperloop Junction stellen. Die Kiste besitzt ein spezielles Menü\\, mit dem man das Pairing von zwei Kisten durchführen kann. Dinge\\, die in der Kiste sind\\, werden zur Gegenstelle teleportiert. Die Kiste kann auch mit einem Schieber gefüllt/geleert werden.\n"..
"\n"..
"Für das Pairing musst du zuerst auf der einen Seite einen Namen für die Kiste eingeben\\, dann kannst du bei der anderen Kiste diesen Namen auswählen und so die beiden Blöcke verbinden.\n"..
"\n"..
"Die Nutzung der TA5 Hyperloop Kiste benötigt 15 Erfahrungspunkte.\n"..
"\n"..
"\n"..
"\n",
"Der TA5 Hyperloop Tank erlaubt den Transport von Flüssigkeiten über ein Hyperloop Netzwerk.\n"..
"\n"..
"Den TA5 Hyperloop Tank muss man dazu auf eine Hyperloop Junction stellen. Der Tank besitzt ein spezielles Menü\\, mit dem man das Pairing von zwei Tanks durchführen kann. Flüssigkeiten\\, die in dem Tank sind\\, werden zur Gegenstelle teleportiert. Der Tank kann auch mit einer Pumpe gefüllt/geleert werden.\n"..
"\n"..
"Für das Pairing musst du zuerst auf der einen Seite einen Namen für den Tank eingeben\\, dann kannst du bei dem anderen Tank diesen Namen auswählen und so die beiden Blöcke verbinden.\n"..
"\n"..
"Die Nutzung des TA5 Hyperloop Tanks benötigt 15 Erfahrungspunkte.\n"..
"\n"..
"\n"..
"\n",
"Dank einem Spezialantrieb für Lichtgeschwindigkeit können mit dem Raumgleiter auch große Entfernungen sehr schnell überwunden werden.\n"..
"\n",
"Mit Teleport-Blöcken können Dinge zwischen zwei Teleport-Blöcken übertragen werden\\, ohne dass sich dazwischen eine Röhre oder Leitung befinden muss. Für das Pairing der Blöcke musst du zuerst auf der einen Seite einen Namen für den Block eingeben\\, dann kannst du bei dem anderen Block diesen Namen auswählen und so die beiden Blöcke verbinden. Das Pairung kann nur von einem Spieler durchgeführt werden (Spielername wird geprüft) und muss vor einem Server-Neustart abgeschlossen sein. Anderenfalls gehen die Pairing-Daten verloren.\n"..
"\n"..
"Der Plan rechts zeigt\\, wie die Blöcke genutzt werden können.\n"..
"\n"..
"\n"..
"\n",
"Diese Teleport-Blöcke erlauben die Übertragung von Gegenständen und ersetzen somit eine Röhre. Dabei können Entfernungen von bis zu 500 Blöcken überbrückt werden.\n"..
"\n"..
"Ein Teleport-Block benötigt 12 ku Strom.\n"..
"\n"..
"Für die Nutzung der Teleport-Blöcke werden 30 Erfahrungspunkte benötigt.\n"..
"\n"..
"\n"..
"\n",
"Diese Teleport-Blöcke erlauben die Übertragung von Flüssigkeiten und ersetzen somit eine gelbe Leitung. Dabei können Entfernungen von bis zu 500 Blöcken überbrückt werden.\n"..
"\n"..
"Ein Teleport-Block benötigt 12 ku Strom.\n"..
"\n"..
"Für die Nutzung der Teleport-Blöcke werden 30 Erfahrungspunkte benötigt.\n"..
"\n"..
"\n"..
"\n",
"Die Hyperloop Teleport Blöcke erlauben den Aufbau von Hyperloop Netzwerk ohne Hyperloop-Röhren.\n"..
"\n"..
"Die Nutzung der Hyperloop Teleport Blöcke benötigt 60 Erfahrungspunkte.\n"..
"\n",
"",
"Der TA5 Container erlaubt Techage Anlagen ein- und an einer anderen Stelle wieder auszupacken.\n"..
"\n"..
"Für die Nutzung des TA5 Containers werden 80 Erfahrungspunkte benötigt.\n"..
"\n",
"Der TA5 KI Chip wird teilweise zur Herstellung von TA5 Blöcken benötigt. Der TA5 KI Chip kann nur auf der TA4 Elektronik Fab hergestellt werden. Dazu werden 10 Erfahrungspunkte benötigt.\n"..
"\n"..
"\n"..
"\n",
"Der TA5 KI Chip II wird zur Herstellung des TA5 Fusionsreaktors benötigt. Der TA5 KI Chip II kann nur auf der TA4 Elektronik Fab hergestellt werden. Dazu werden 25 Erfahrungspunkte benötigt.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta5",
"",
"",
"ta5_magnet",
"ta5_pump",
"",
"ta5_fr_controller",
"ta5_fr_shell",
"ta5_fr_nucleus",
"",
"",
"",
"",
"ta5_flycontroller",
"ta5_chest",
"ta5_tank",
"",
"",
"ta5_tele_tube",
"ta5_tele_pipe",
"",
"",
"",
"ta5_aichip",
"ta5_aichip2",
},
plans = {
"",
"",
"ta5_fusion_reactor",
"",
"",
"ta5_heatexchanger",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta5_teleport",
"",
"",
"",
"",
"",
"",
"",
}
}

214
doc/manual_ta5_EN.lua Normal file
View File

@ -0,0 +1,214 @@
return {
titles = {
"1,TA5: Future",
"2,Energy Sources",
"3,TA5 Fusion Reactor",
"4,TA5 Fusion Reactor Magnet",
"4,TA5 Pump",
"4,TA5 Heat Exchanger",
"4,TA5 Fusion Reactor Controller",
"4,TA5 Fusion Reactor Shell",
"4,TA5 Fusion Reactor Core",
"2,Energy Storage",
"3,TA5 Hybrid Storage (planned)",
"2,Logic blocks",
"2,Transport and Traffic",
"3,TA5 Flight Controller",
"3,TA5 Hyperloop Chest",
"3,TA5 Hyperloop Tank",
"2,Teleport Blocks",
"3,TA5 Teleport Block Items",
"3,TA5 Teleport Block Liquids",
"3,Hyperloop Teleport Blocks (planned)",
"2,More TA5 Blocks/Items",
"3,TA5 Container (planned)",
"3,TA5 AI Chip",
"3,TA5 AI Chip II",
},
texts = {
"Machines to overcome space and time\\, new sources of energy and other achievements shape your life.\n"..
"\n"..
"Experience points are required for the manufacture and use of TA5 machines and blocks. These can only be worked out using the collider from TA4.\n"..
"\n"..
"\n"..
"\n",
"",
"Nuclear fusion means the fusing of two atomic nuclei. Depending on the reaction\\, large amounts of energy can be released. Nuclear fusions\\, in which energy is released\\, take place in the form of chain reactions. They are the source of the energy of the stars\\, including our sun\\, for example. A fusion reactor converts the energy released during controlled nuclear fusion into electricity.\n"..
"\n"..
"*How do fusion reactors work?*\n"..
"\n"..
"A fusion reactor works according to the classic principle of a thermal power plant: water is heated and drives a steam turbine\\, whose kinetic energy is converted into electricity by a generator.\n"..
"\n"..
"A fusion power plant initially requires a large amount of energy\\, since a plasma has to be generated. \"Plasma\" is the name given to the fourth state of matter\\, after solid\\, liquid and gaseous. This requires a lot of electricity. Only through this extreme concentration of energy does the fusion reaction ignite and the heat given off is used to generate electricity via the heat exchanger. The generator then delivers 800 ku of electricity.\n"..
"\n"..
"The plan on the right shows a section through the fusion reactor.\n"..
"\n"..
"60 experience points are required to operate the fusion reactor. The fusion reactor must be built entirely in a forceload block area.\n"..
"\n"..
"\n"..
"\n",
"A total of 60 TA5 Fusion Reactor Magnets are required to set up the fusion reactor. These form the ring in which the plasma forms. The TA5 Fusion Reactor Magnets requires power and has two ports for cooling.\n"..
"\n"..
"There are two types of magnets\\, so all sides of the magnet that face the plasma ring can also be protected with a heat shield.\n"..
"\n"..
"With the corner magnets on the inside of the ring\\, one connection side is covered (power or cooling) and can therefore not be connected. This is technically not feasible and therefore has no influence on the function of the fusion reactor. \n"..
"\n"..
"\n"..
"\n",
"The pump is required to fill the cooling circuit with isobutane. About 350 units of isobutane are required.\n"..
"\n"..
"Note: The TA5 pump can only be used to fill the cooling circuit\\, pumping out the coolant is not possible. Therefore\\, the pump should not be switched on until the magnets are correctly placed and all power and cooling lines are connected.\n"..
"\n"..
"\n"..
"\n",
"The TA5 Heat Exchanger is required to convert the heat generated in the fusion reactor first to steam and then to electricity. The Heat Exchanger itself requires 5 ku electricity. The structure is similar to the Heat Exchanger of the energy store from TA4.\n"..
"\n"..
"Note: The TA5 Heat Exchanger has two connections (blue and green) for the cooling circuit. The heat exchanger and all magnets must be connected to form a cooling circuit via the green and blue pipes.\n"..
"\n"..
"The cooling circuit can be checked for completeness using the start button on the heat exchanger\\, even if no coolant has yet been filled in.\n"..
"\n"..
"\n"..
"\n",
"The fusion reactor is switched on via the TA5 Fusion Reactor Controller. The cooling/Heat Exchanger must be switched on first and then the controller. It takes about 2 minutes for the reactor to start up and supply electricity. The fusion reactor and thus the controller requires 400 ku of electricity to maintain the plasma.\n"..
"\n"..
"\n"..
"\n",
"The entire reactor must be surrounded by a shell that absorbs the enormous pressure that the magnets exert on the plasma and protects the environment from radiation. Without this shell\\, the reactor cannot be started. With the TechAge Trowel\\, power cables and cooling pipes of the fusion reactor can also be integrated into the shell.\n"..
"\n"..
"\n"..
"\n",
"The core must sit in the center of the reactor. See illustration under \"TA5 Fusion Reactor\". The TechAge Trowel is also required for this.\n"..
"\n"..
"\n"..
"\n",
"",
"",
"",
"",
"The TA5 Flight Controller is similar to the TA4 Move Controller. In contrast to the TA4 Move Controller\\, several movements can be combined into one flight route. This flight route can be defined in the input field using several x\\,y\\,z entries (one movement per line). The flight route is checked and saved via \"Save\". In the event of an error\\, an error message is issued.\n"..
"\n"..
"With the \"Test\" button\\, the flight route with the absolute coordinates is output for checking in the chat.\n"..
"\n"..
"The maximum distance for the entire flight distance is 1500 m. Up to 32 blocks can be trained.\n"..
"\n"..
"The use of the TA5 Flight Controller requires 40 experience points.\n"..
"\n"..
"*Teleport mode*\n"..
"\n"..
"If the 'Teleport Mode' is enabled\\, a player can also be moved without blocks. To do this\\, the start position must be configured using the \"Record\" button. Only one position can be configured here. The player to be moved must be in that position.\n"..
"\n"..
"\n"..
"\n",
"The TA5 Hyperloop Chest allows objects to be transported over a Hyperloop network.\n"..
"\n"..
"The TA5 Hyperloop Chest has to be placed on a Hyperloop Junction. The chest has a special menu\\, with which you can pair two chests. Things that are in the chest are teleported to the remote station. The chest can also be filled/emptied with a pusher.\n"..
"\n"..
"For pairing you first have to enter a name for the chest on one side\\, then you can select this name for the other chest and thus connect the two blocks.\n"..
"\n"..
"The use of the TA5 Hyperloop Chest requires 15 experience points.\n"..
"\n"..
"\n"..
"\n",
"The TA5 Hyperloop Tank allows liquids to be transported over a Hyperloop network.\n"..
"\n"..
"The TA5 Hyperloop Tank has to be placed on a Hyperloop Junction.The tank has a special menu\\, with which you can pair two tanks. Liquids in the tank will be teleported to the remote station. The tank can also be filled/emptied with a pump.\n"..
"\n"..
"For pairing you first have to enter a name for the tank on one side\\, then you can select this name for the other tank and thus connect the two blocks.\n"..
"\n"..
"The use of the TA5 Hyperloop Tank requires 15 experience points.\n"..
"\n"..
"\n"..
"\n",
"Teleport blocks allow things to be transferred between two teleport blocks without the need for a pipe or tube in between. To pair the blocks\\, you first have to enter a name for the block on one side\\, then you can select this name for the other block and thus connect the two blocks. Pairing can only be carried out by one player (player name is checked) and must be completed before the server is restarted. Otherwise the pairing data will be lost.\n"..
"\n"..
"The map on the right shows how the blocks can be used. \n"..
"\n"..
"\n"..
"\n",
"These teleport blocks allow the transfer of items and thus replace a tube. Distances of up to 500 blocks can be bridged.\n"..
"\n"..
"Each Teleport blocks requires 12 ku of electricity.\n"..
"\n"..
"30 experience points are required to use the teleport blocks. \n"..
"\n"..
"\n"..
"\n",
"These teleport blocks allow the transfer of liquids and thus replace a pipe. Distances of up to 500 blocks can be bridged.\n"..
"\n"..
"Each Teleport blocks requires 12 ku of electricity.\n"..
"\n"..
"30 experience points are required to use the teleport blocks. \n"..
"\n"..
"\n"..
"\n",
"The Hyperloop Teleport Blocks allow the construction of a Hyperloop network without Hyperloop tubes.\n"..
"\n"..
"The use of the Hyperloop Teleport Blocks requires 60 experience points.\n"..
"\n",
"",
"The TA5 container allows Techage systems to be packed and unpacked at another location.\n"..
"\n"..
"80 experience points are required to use the TA5 container.\n"..
"\n",
"The TA5 AI Chip is partly required for the production of TA5 blocks. The TA5 AI Chip can only be manufactured at the TA4 Electronics Fab. This requires 10 experience points.\n"..
"\n"..
"\n"..
"\n",
"The TA5 AI Chip II is required to build the TA5 Fusion Reactor. The TA5 AI Chip II can only be manufactured at the TA4 Electronics Fab. This requires 25 experience points.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta5",
"",
"",
"ta5_magnet",
"ta5_pump",
"",
"ta5_fr_controller",
"ta5_fr_shell",
"ta5_fr_nucleus",
"",
"",
"",
"",
"ta5_flycontroller",
"ta5_chest",
"ta5_tank",
"",
"ta5_tele_tube",
"ta5_tele_pipe",
"",
"",
"",
"ta5_aichip",
"ta5_aichip2",
},
plans = {
"",
"",
"ta5_fusion_reactor",
"",
"",
"ta5_heatexchanger",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta5_teleport",
"",
"",
"",
"",
"",
"",
"",
}
}

214
doc/manual_ta5_pt-BR.lua Normal file
View File

@ -0,0 +1,214 @@
return {
titles = {
"1,TA5: Futuro",
"2,Fontes de energia",
"3,Reator de fusão TA5",
"4,Ímã do reator de fusão TA5",
"4,Bomba TA5",
"4,Trocador de calor TA5",
"4,Controlador do reator de fusão TA5",
"4,Carcaça do reator de fusão TA5",
"4,Núcleo do reator de fusão TA5",
"2,Armazenamento de energia",
"3,Armazenamento híbrido TA5 (planejado)",
"2,Blocos lógicos",
"2,Transporte e tráfego",
"3,Controlador de voo TA5",
"3,TA5 Hyperloop Chest",
"3,Tanque de hyperloop TA5",
"2,Blocos de teletransporte",
"3,Itens do bloco de teletransporte TA5",
"3,Líquidos do bloco de teletransporte TA5",
"3,Blocos de teletransporte Hyperloop (planejados)",
"2,Mais blocos/itens TA5",
"3,Contêiner TA5 (planejado)",
"3,Chip TA5 AI",
"3,Chip TA5 AI II",
},
texts = {
"Máquinas para superar o espaço e o tempo\\, novas fontes de energia e outras conquistas moldam sua vida.\n"..
"\n"..
"São necessários pontos de experiência para a fabricação e o uso de máquinas e blocos TA5. Eles só podem ser calculados usando o colisor do TA4.\n"..
"\n"..
"\n"..
"\n",
"",
"A fusão nuclear significa a fusão de dois núcleos atômicos. Dependendo da reação\\, grandes quantidades de energia podem ser liberadas. As fusões nucleares\\, nas quais a energia é liberada\\, ocorrem na forma de reações em cadeia. Elas são a fonte de energia das estrelas\\, inclusive do nosso sol\\, por exemplo. Um reator de fusão converte a energia liberada durante a fusão nuclear controlada em eletricidade.\n"..
"\n"..
"*Como funcionam os reatores de fusão?*\n"..
"\n"..
"Um reator de fusão funciona de acordo com o princípio clássico de uma usina de energia térmica: a água é aquecida e aciona uma turbina a vapor\\, cuja energia cinética é convertida em eletricidade por um gerador.\n"..
"\n"..
"Uma usina de fusão requer inicialmente uma grande quantidade de energia\\, pois é necessário gerar um plasma. \"Plasma\" é o nome dado ao quarto estado da matéria\\, depois do sólido\\, líquido e gasoso. Isso requer uma grande quantidade de eletricidade. Somente por meio dessa concentração extrema de energia é que a reação de fusão se inflama e o calor liberado é usado para gerar eletricidade por meio do trocador de calor. O gerador fornece então 800 ku de eletricidade.\n"..
"\n"..
"A planta à direita mostra uma seção do reator de fusão.\n"..
"\n"..
"São necessários 60 pontos de experiência para operar o reator de fusão. O reator de fusão deve ser construído inteiramente em uma área de bloco de carga.\n"..
"\n"..
"\n"..
"\n",
"Um total de 60 ímãs de reator de fusão TA5 é necessário para configurar o reator de fusão. Eles formam o anel no qual o plasma se forma. O TA5 Fusion Reactor Magnets requer energia e tem duas portas para resfriamento.\n"..
"\n"..
"Há dois tipos de ímãs\\, portanto\\, todos os lados do ímã voltados para o anel de plasma também podem ser protegidos com um protetor térmico.\n"..
"\n"..
"Com os ímãs de canto na parte interna do anel\\, um lado da conexão é coberto (energia ou resfriamento) e\\, portanto\\, não pode ser conectado. Isso não é tecnicamente viável e\\, portanto\\, não influencia a função do reator de fusão. \n"..
"\n"..
"\n"..
"\n",
"A bomba é necessária para encher o circuito de resfriamento com isobutano. São necessárias cerca de 350 unidades de isobutano.\n"..
"\n"..
"Observação: A bomba TA5 só pode ser usada para encher o circuito de resfriamento\\; não é possível bombear o líquido de arrefecimento para fora. Portanto\\, a bomba não deve ser ligada até que os ímãs estejam corretamente posicionados e todas as linhas de alimentação e resfriamento estejam conectadas.\n"..
"\n"..
"\n"..
"\n",
"O trocador de calor TA5 é necessário para converter o calor gerado no reator de fusão primeiro em vapor e depois em eletricidade. O próprio trocador de calor requer 5 ku de eletricidade. A estrutura é semelhante à do trocador de calor do depósito de energia do TA4.\n"..
"\n"..
"Observação: O trocador de calor TA5 tem duas conexões (azul e verde) para o circuito de resfriamento. O trocador de calor e todos os ímãs devem ser conectados para formar um circuito de resfriamento por meio dos tubos verde e azul.\n"..
"\n"..
"É possível verificar se o circuito de resfriamento está completo usando o botão de partida no trocador de calor\\, mesmo que o líquido de arrefecimento ainda não tenha sido abastecido.\n"..
"\n"..
"\n"..
"\n",
"O reator de fusão é ligado por meio do controlador do reator de fusão TA5. O resfriamento/trocador de calor deve ser ligado primeiro e depois o controlador. Leva cerca de 2 minutos para o reator iniciar e fornecer eletricidade. O reator de fusão e\\, portanto\\, o controlador requerem 400 ku de eletricidade para manter o plasma.\n"..
"\n"..
"\n"..
"\n",
"O reator inteiro deve ser cercado por um invólucro que absorva a enorme pressão que os ímãs exercem sobre o plasma e proteja o ambiente da radiação. Sem esse invólucro\\, o reator não pode ser iniciado. Com a TechAge Trowel\\, os cabos de energia e os tubos de resfriamento do reator de fusão também podem ser integrados à carcaça.\n"..
"\n"..
"\n"..
"\n",
"O núcleo deve ficar no centro do reator. Veja a ilustração em \"TA5 Fusion Reactor\". A espátula TechAge também é necessária para isso.\n"..
"\n"..
"\n"..
"\n",
"",
"",
"",
"",
"O controlador de voo TA5 é semelhante ao controlador de movimento TA4. Ao contrário do TA4 Move Controller\\, vários movimentos podem ser combinados em uma rota de voo. Essa rota de voo pode ser definida no campo de entrada usando várias entradas x\\,y\\,z (um movimento por linha). A rota de voo é verificada e salva por meio de \"Save\" (Salvar). Em caso de erro\\, é emitida uma mensagem de erro.\n"..
"\n"..
"Com o botão \"Test\" (Testar)\\, a rota de voo com as coordenadas absolutas é emitida para verificação no bate-papo.\n"..
"\n"..
"A distância máxima para toda a distância de voo é de 1.500 m. Até 32 blocos podem ser treinados.\n"..
"\n"..
"O uso do controlador de voo TA5 requer 40 pontos de experiência.\n"..
"\n"..
"*Modo teletransporte*\n"..
"\n"..
"Se o \"Teleport Mode\" (Modo de teletransporte) estiver ativado\\, o jogador também poderá ser movido sem blocos. Para fazer isso\\, a posição inicial deve ser configurada usando o botão \"Record\" (Registrar). Somente uma posição pode ser configurada aqui. O jogador a ser movido deve estar nessa posição.\n"..
"\n"..
"\n"..
"\n",
"O TA5 Hyperloop Chest permite que objetos sejam transportados em uma rede Hyperloop.\n"..
"\n"..
"O Baú Hyperloop TA5 deve ser colocado em uma Junção Hyperloop. O baú tem um menu especial\\, com o qual você pode emparelhar dois baús. Os itens que estão no baú são teletransportados para a estação remota. O baú também pode ser preenchido/esvaziado com um empurrador.\n"..
"\n"..
"Para fazer o emparelhamento\\, primeiro você precisa inserir um nome para o baú de um lado e\\, em seguida\\, selecionar esse nome para o outro baú e\\, assim\\, conectar os dois blocos.\n"..
"\n"..
"O uso do Baú do Hyperloop TA5 requer 15 pontos de experiência.\n"..
"\n"..
"\n"..
"\n",
"O TA5 Hyperloop Tank permite o transporte de líquidos em uma rede Hyperloop.\n"..
"\n"..
"O TA5 Hyperloop Tank deve ser colocado em um Hyperloop Junction. O tanque tem um menu especial\\, com o qual você pode emparelhar dois tanques. Os líquidos no tanque serão teletransportados para a estação remota. O tanque também pode ser enchido/esvaziado com uma bomba.\n"..
"\n"..
"Para fazer o emparelhamento\\, primeiro é necessário inserir um nome para o tanque de um lado e\\, em seguida\\, selecionar esse nome para o outro tanque e\\, assim\\, conectar os dois blocos.\n"..
"\n"..
"O uso do TA5 Hyperloop Tank requer 15 pontos de experiência.\n"..
"\n"..
"\n"..
"\n",
"Os blocos de teletransporte permitem a transferência de objetos entre dois blocos de teletransporte sem a necessidade de um cano ou tubo entre eles. Para emparelhar os blocos\\, primeiro é preciso digitar um nome para o bloco de um lado e\\, em seguida\\, selecionar esse nome para o outro bloco e\\, assim\\, conectar os dois blocos. O emparelhamento só pode ser realizado por um jogador (o nome do jogador é verificado) e deve ser concluído antes de o servidor ser reiniciado. Caso contrário\\, os dados de emparelhamento serão perdidos.\n"..
"\n"..
"O mapa à direita mostra como os blocos podem ser usados. \n"..
"\n"..
"\n"..
"\n",
"Esses blocos de teletransporte permitem a transferência de itens e\\, portanto\\, substituem um tubo. Distâncias de até 500 blocos podem ser transpostas.\n"..
"\n"..
"Cada bloco de teletransporte requer 12 ku de eletricidade.\n"..
"\n"..
"São necessários 30 pontos de experiência para usar os blocos de teletransporte. \n"..
"\n"..
"\n"..
"\n",
"Esses blocos de teletransporte permitem a transferência de líquidos e\\, portanto\\, substituem um cano. Distâncias de até 500 blocos podem ser transpostas.\n"..
"\n"..
"Cada bloco de teletransporte requer 12 ku de eletricidade.\n"..
"\n"..
"São necessários 30 pontos de experiência para usar os blocos de teletransporte. \n"..
"\n"..
"\n"..
"\n",
"Os blocos de teletransporte Hyperloop permitem a construção de uma rede Hyperloop sem tubos Hyperloop.\n"..
"\n"..
"O uso dos blocos de teletransporte Hyperloop requer 60 pontos de experiência.\n"..
"\n",
"",
"O contêiner TA5 permite que os sistemas Techage sejam embalados e desembalados em outro local.\n"..
"\n"..
"São necessários 80 pontos de experiência para usar o contêiner TA5.\n"..
"\n",
"O chip TA5 AI é parcialmente necessário para a produção de blocos TA5. O chip de IA TA5 só pode ser fabricado na fábrica de eletrônicos TA4. Isso requer 10 pontos de experiência.\n"..
"\n"..
"\n"..
"\n",
"O TA5 AI Chip II é necessário para construir o Reator de Fusão TA5. O TA5 AI Chip II só pode ser fabricado na fábrica de eletrônicos TA4. Isso requer 25 pontos de experiência.\n"..
"\n"..
"\n"..
"\n",
},
images = {
"techage_ta5",
"",
"",
"ta5_magnet",
"ta5_pump",
"",
"ta5_fr_controller",
"ta5_fr_shell",
"ta5_fr_nucleus",
"",
"",
"",
"",
"ta5_flycontroller",
"ta5_chest",
"ta5_tank",
"",
"ta5_tele_tube",
"ta5_tele_pipe",
"",
"",
"",
"ta5_aichip",
"ta5_aichip2",
},
plans = {
"",
"",
"ta5_fusion_reactor",
"",
"",
"ta5_heatexchanger",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"ta5_teleport",
"",
"",
"",
"",
"",
"",
"",
}
}

View File

@ -12,7 +12,7 @@
]]--
techage.ConstructionPlans = {}
local plans = {}
local IMG_1 = {"", "techage_ta1.png"}
@ -26,6 +26,7 @@ local IMG43 = {"", "techage_reactor_inv.png"}
local IMG44 = {"", "techage_ta4_filter.png"}
local IMG45 = {"10x10", "techage_collider_plan.png"}
local IMG46 = {"5x4", "techage_fusion_reactor.png"}
local IMG47 = {"5x4", "techage_collider_plan2.png"}
local TOP_V = {"top_view", ""}
local SIDEV = {"side_view", ""}
@ -38,7 +39,7 @@ local DDIRT = {"default_dirt.png", "default:dirt"}
local DWOOD = {"default_wood.png" , "default:wood"}
local LIGTR = {"techage_lighter.png", "techage:lighter"}
techage.ConstructionPlans["coalpile"] = {
plans["coalpile"] = {
{false, false, SIDEV, false, false, false, false, false, TOP_V, false, false},
{false, false, false, false, false, false, false, false, false, false, false},
{DDIRT, DDIRT, DDIRT, DDIRT, DDIRT, false, DDIRT, DDIRT, DDIRT, DDIRT, DDIRT},
@ -57,7 +58,7 @@ local CCOAL = {"techage_charcoal.png", "techage:charcoal"}
local MEPOT = {"default_cobble.png^techage_meltingpot.png", "techage:meltingpot"}
local FLAME = {"techage_flame.png", nil}
techage.ConstructionPlans["coalburner"] = {
plans["coalburner"] = {
{false, false, SIDEV, false, false, false, false},
{false, false, MEPOT, false, false, IMG_1, false},
{false, false, FLAME, false},
@ -76,7 +77,7 @@ local CHEST = {"default_chest_lock.png", "default:chest_locked"}
local HOPPR = {"techage_hopper.png^[transformFX", "minecart:hopper"}
local SIEVE = {"techage_sieve_sieve_ta1.png", "techage:sieve3"}
techage.ConstructionPlans["hoppersieve"] = {
plans["hoppersieve"] = {
{false, false, false, false, false},
{false, false, false, false, false},
{false, CHEST, false, false, false},
@ -110,7 +111,7 @@ local BEARG = {"default_stone_brick.png^techage_axle_bearing_front.png", "techag
local BRICK = {"default_stone_brick.png", "default:stonebrick"}
techage.ConstructionPlans["watermill1"] = {
plans["watermill1"] = {
{false, false, false, false, false, false, false, false, false, false, false, false},
{false, false, SLUC2, false, false, false, false, false, false, false, false, false},
{WATR4, WATR4, SLUC1, WMILL, WMILL, WMILL, WMILL, WMILL, WATR3, false, false, false},
@ -131,7 +132,7 @@ local MILLB = {"default_stone_brick.png", "techage:ta1_mill_base"}
local FURNE = {"default_furnace_front.png", "default:furnace"}
local HOPER = {"techage_hopper.png", "minecart:hopper"}
techage.ConstructionPlans["watermill2"] = {
plans["watermill2"] = {
{false, false, false, false, false, false, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false, false, false},
@ -157,7 +158,7 @@ local FIBOX = {"techage_firebox.png^techage_appl_firehole.png^techage_frame_ta2.
local CYLIN = {"techage_filling_ta2.png^techage_cylinder.png^techage_frame_ta2.png", "techage:cylinder"}
local FLYWH = {"techage_filling_ta2.png^techage_frame_ta2.png^techage_flywheel.png^[transformFX]", "techage:flywheel"}
techage.ConstructionPlans["steamengine"] = {
plans["steamengine"] = {
{false, false, false, false, false, IMG_2, false},
{false, false, false, false, false, false, false},
{false, PK000, PI000, PK270, false, false, false},
@ -175,8 +176,9 @@ local AXL90 = {"techage_axle.png^[transformR90", "techage:axle"}
local WINCH = {"techage_filling_ta2.png^techage_appl_winch.png^techage_frame_ta2.png", "techage:ta2_winch"}
local ROPE_ = {"techage_rope_inv.png", "techage:ta2_rope"}
local WCHST = {"techage_filling_ta2.png^techage_frame_ta2.png^techage_appl_chest_back_ta3.png^techage_weight_side.png", "techage:ta2_weight_chest"}
local CLTCH = {"techage_filling_ta2.png^techage_appl_clutch.png^techage_frame_ta2.png", "techage:ta2_clutch_off"}
techage.ConstructionPlans["ta2_storage"] = {
plans["ta2_storage"] = {
{false, false, false, GRBOX, WINCH, false, SIDEV},
{false, false, false, AXL90, ROPE_, false, false},
{false, false, false, AXL90, ROPE_, false, false},
@ -186,7 +188,7 @@ techage.ConstructionPlans["ta2_storage"] = {
{false, false, false, AXL90, ROPE_, false, false},
{false, false, false, AXL90, WCHST, false, false},
{false, false, false, AXL90, false, false, false},
{AXL00, AXL00, AXL00, GRBOX, false, false, false},
{AXL00, CLTCH, AXL00, GRBOX, false, false, false},
}
--
@ -198,7 +200,7 @@ local GRIND = {"techage_filling_ta2.png^techage_appl_grinder2.png^techage_frame_
local DISTR = {"techage_filling_ta2.png^techage_frame_ta2.png^techage_appl_distri_blue.png", "techage:ta2_distributor_pas"}
local SIEV2 = {"techage_filling_ta2.png^techage_appl_sieve.png^techage_frame_ta2.png", "techage:ta2_gravelsieve_pas"}
techage.ConstructionPlans["itemtransport"] = {
plans["itemtransport"] = {
{false, false, false, false, false, false, false, false, false, false, false},
{false},
{false},
@ -217,7 +219,7 @@ local TK090 = {"techage_tube_knee.png^[transformR90", "techage:tubeS"} -- '7'
local TK180 = {"techage_tube_knee.png^[transformR180", "techage:tubeS"}
local TK270 = {"techage_tube_knee.png^[transformR270", "techage:tubeS"}
techage.ConstructionPlans["gravelrinser"] = {
plans["gravelrinser"] = {
{false, false, false, SIDEV, false, false, false, false},
{false, GLASS, WATER, GLASS, GLASS, GLASS, GLASS, GLASS},
{false, DDIRT, DDIRT, TK000, RINSR, TK270, HOPPR, CHEST},
@ -239,7 +241,7 @@ local GENE3 = {"techage_filling_ta3.png^techage_frame_ta3.png^techage_appl_gener
local COOL3 = {"techage_filling_ta3.png^techage_frame_ta3.png^techage_cooler.png", "techage:cooler"}
local PK180 = {"techage_steam_knee.png^[transformR180", "techage:steam_pipeS"}
techage.ConstructionPlans["coalpowerstation"] = {
plans["coalpowerstation"] = {
{false, false, false, false, false, false, false, false},
{false, PK000, PI000, PI000, PI000, PI000, PI000, PK270},
{false, PI090, BOIL3, PI000, PK270, PK000, COOL3, PK180},
@ -259,7 +261,7 @@ local Boost = {"techage_filling_ta3.png^techage_appl_compressor.png^[transformFX
local Fibox = {"techage_concrete.png^techage_appl_firehole.png^techage_frame_ta3.png", "techage:furnace_firebox"}
local Furnc = {"techage_concrete.png^techage_appl_furnace.png^techage_frame_ta3.png", "techage:ta3_furnace_pas"}
techage.ConstructionPlans["ta3_furnace"] = {
plans["ta3_furnace"] = {
{false, false, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false},
{false, Tubes, PushR, Tubes, Furnc, Tubes, PushR, Tubes},
@ -280,7 +282,7 @@ local PN090 = {"techage_gaspipe_knee.png^[transformR90", "techage:ta4_pipeS"}
local PN180 = {"techage_gaspipe_knee.png^[transformR180", "techage:ta4_pipeS"} -- J
local PN270 = {"techage_gaspipe_knee.png^[transformR270", "techage:ta4_pipeS"} -- 7
techage.ConstructionPlans["ta3_tank"] = {
plans["ta3_tank"] = {
{false, false, false, false, SIDEV, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false},
{false, Tubes, PushR, Tubes, Fillr, Tubes, PushR, Tubes, false, false},
@ -302,7 +304,7 @@ local RAILH = {"carts_rail_straight.png^[transformR90", "carts:rail"}
local CRAIL = {"carts_rail_curved.png^[transformR90", "carts:rail"}
local BUFFR = {"default_junglewood.png^minecart_buffer.png", "minecart:buffer"}
techage.ConstructionPlans["ta3_loading"] = {
plans["ta3_loading"] = {
{false, false, PIPEH, Pump, PIPEH, PN270, SIDEV, false, false, false, false},
{false, false, false, false, false, PIPEV, false, false, false, false, false},
{false, MCART, false, false, false, PN090, TANK3, false, false, false, false},
@ -325,7 +327,7 @@ local DIST1 = {"techage_distiller_inv.png", "techage:ta3_distiller1"}
local DBASE = {"techage_concrete.png", "techage:ta3_distiller_base"}
local REBIO = {"techage_filling_ta3.png^techage_appl_reboiler.png^techage_frame_ta3.png", "techage:ta3_reboiler"}
techage.ConstructionPlans["ta3_distiller"] = {
plans["ta3_distiller"] = {
{false, false, false, false, false, SIDEV, false, PN000, PIPEH, TANK3, false},
{false, IMG31, false, false, false, false, false, DIST4, false, false, false},
{false, false, false, false, false, false, false, DIST3, PIPEH, TANK3, false},
@ -341,22 +343,23 @@ techage.ConstructionPlans["ta3_distiller"] = {
--
-- Chemical Reactor
--
local RBASE = {"techage_concrete.png", "techage:ta4_reactor_stand"}
local RBASE = {"techage_concrete.png", "techage:ta4_reactor_base"}
local STAND = {"techage_reactor_stand_side.png", "techage:ta4_reactor_stand"}
local REACT = {"techage_reactor_plan.png", "techage:ta4_reactor"}
local FILLR = {"techage_reactor_filler_plan.png", "techage:ta4_reactor_fillerpipe"}
local DOSER = {"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_pump_up.png", "techage:ta4_doser"}
local SILO = {"techage_filling_ta3.png^techage_frame_ta3.png^techage_appl_silo.png", "techage:ta3_silo"}
local SILO4 = {"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_silo.png", "techage:ta4_silo"}
local TANK4 = {"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_tank.png", "techage:ta4_tank"}
techage.ConstructionPlans["ta4_reactor"] = {
plans["ta4_reactor"] = {
{false, false, false, false, false, false, SIDEV, false, false, false, false},
{false, IMG43, false, false, false, false, false, false, false, false, false},
{false, false, false, false, PN000, PIPEH, PIPEH, PN270, false, false, false},
{false, false, false, false, PIPEV, false, false, FILLR, false, false, false},
{false, false, false, false, PIPEV, false, false, REACT, false, false, false},
{false, false, false, false, PIPEV, false, false, STAND, PIPEH, PIPEH, SILO},
{false, TANK3, PIPEH, PIPEH, DOSER, PN270, false, RBASE, PIPEH, PIPEH, TANK3},
{false, SILO, PIPEH, PIPEH, PIPEH, PN180, false, false, false, false, false},
{false, false, false, false, PIPEV, false, false, STAND, PIPEH, PIPEH, SILO4},
{false, TANK4, PIPEH, PIPEH, DOSER, PN270, false, RBASE, PIPEH, PIPEH, TANK4},
{false, SILO4, PIPEH, PIPEH, PIPEH, PN180, false, false, false, false, false},
}
--
@ -367,7 +370,7 @@ local NCLLE = {"techage_rotor.png", "techage:ta4_wind_turbine_nacelle"}
local PILLR = {"techage:pillar", "techage:pillar"}
local SLAMP = {"techage:rotor_signal_lamp_off", "techage:rotor_signal_lamp_off"}
techage.ConstructionPlans["ta4_windturbine"] = {
plans["ta4_windturbine"] = {
{false, false, false, SIDEV, false, false, false},
{false, false, false, SLAMP, false, false, IMG_4, false},
{false, false, false, ROTOR, NCLLE, false, false},
@ -393,7 +396,7 @@ local GRAVL = {"default_gravel.png", "default:gravel"}
local INLET = {"basic_materials_concrete_block.png^techage_gaspipe.png^[transformR90", "techage:ta4_pipe_inlet"}
local OGLAS = {"default_obsidian_glass.png", "default:obsidian_glass"}
techage.ConstructionPlans["ta4_storagesystem"] = {
plans["ta4_storagesystem"] = {
{false, false, TOP_V, false, false, false, false, SIDEV, false, IMG41, false},
{false, false, PN000, PIPEH, PIPEH, PIPEH, PN270, false, false, false, false},
{CONCR, CONCR, INLET, CONCR, CONCR, false, PIPEV, false, false, false, false},
@ -413,7 +416,7 @@ local RCBLE = {"techage_ta4_cable_inv.png", "techage:ta4_power_cableS"}
local CARRI = {"techage:ta4_solar_carrier", "techage:ta4_solar_carrier"}
local INVAC = {"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_inverter.png", "techage:ta4_solar_inverter"}
techage.ConstructionPlans["ta4_solarplant"] = {
plans["ta4_solarplant"] = {
{false, false, false, false, false, false, false, false, false, IMG42, false},
{false, false, TOP_V, false, false, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false, false},
@ -432,7 +435,7 @@ local PWETR = {"basic_materials_concrete_block.png^techage_gaspipe.png", "techag
local TANK4 = {"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_tank.png", "techage:ta4_tank"}
local LFFIL = {"basic_materials_concrete_block.png^techage_gaspipe_hole.png", "techage:ta4_liquid_filter_filler"}
techage.ConstructionPlans["ta4_liquid_filter_base"] = {
plans["ta4_liquid_filter_base"] = {
{false, false, false, false, false, false, false, false, IMG44, false},
{false, false, false, TOP_V, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false},
@ -443,7 +446,7 @@ techage.ConstructionPlans["ta4_liquid_filter_base"] = {
{false, CONCR, CONCR, CONCR, CONCR, CONCR},
}
techage.ConstructionPlans["ta4_liquid_filter_gravel"] = {
plans["ta4_liquid_filter_gravel"] = {
{false, false, false, false, false, false, false, false, IMG44, false},
{false, false, false, TOP_V, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false},
@ -454,7 +457,7 @@ techage.ConstructionPlans["ta4_liquid_filter_gravel"] = {
{false, CONCR, OGLAS, OGLAS, OGLAS, CONCR},
}
techage.ConstructionPlans["ta4_liquid_filter_top"] = {
plans["ta4_liquid_filter_top"] = {
{false, false, false, false, false, false, false, false, IMG44, false},
{false, false, false, TOP_V, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false},
@ -471,7 +474,7 @@ techage.ConstructionPlans["ta4_liquid_filter_top"] = {
local STEEL = {"default_steel_block.png", "techage:ta4_colliderblock"}
local COOL4 = {"techage_filling_ta4.png^techage_frame_ta4.png^techage_cooler.png", "techage:ta4_collider_cooler"}
techage.ConstructionPlans["techage_collider_plan"] = {
plans["techage_collider_plan"] = {
{IMG45, false, false, false},
{false, false, false, false},
{false, false, false, false},
@ -480,13 +483,22 @@ techage.ConstructionPlans["techage_collider_plan"] = {
{false, false, false, false},
}
plans["techage_collider_plan2"] = {
{false, false, false, false},
{false, false, false, false},
{false, false, IMG47, false},
{false, false, false, false},
{false, false, false, false},
{false, false, false, false},
}
--
-- TA4 Detector Cooler
--
local STEEL = {"default_steel_block.png", "techage:ta4_colliderblock"}
local COOL4 = {"techage_filling_ta4.png^techage_frame_ta4.png^techage_cooler.png", "techage:ta4_collider_cooler"}
techage.ConstructionPlans["ta4_cooler"] = {
plans["ta4_cooler"] = {
{false, false, false, SIDEV, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false},
{false, STEEL, PIPEH, HEXR1, PIPEH, COOL4, PN270, false, false},
@ -503,7 +515,7 @@ local TELET = {"techage_filling_ta4.png^techage_frame_ta5.png^techage_appl_telep
local PUMP4 = {"techage_filling_ta4.png^techage_appl_pump.png^techage_frame_ta4.png", "techage:t4_pump"}
local ARROW = {"techage_form_arrow.png"}
techage.ConstructionPlans["ta5_teleport"] = {
plans["ta5_teleport"] = {
{false, false, false, false, false, false, false, false, false, false, false},
{false, CHEST, PushR, TELET, false, ARROW, false, TELET, Tubes, CHEST, false},
{false, false, false, false, false, false, false, false, false, false, false},
@ -511,8 +523,6 @@ techage.ConstructionPlans["ta5_teleport"] = {
{false, false, false, false, false, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false, false},
{false, TANK4, PUMP4, TELEP, false, ARROW, false, TELEP, PIPEH, TANK4, false},
{false, false, false, false, false, false, false, false, false, false, false},
{false, TANK4, PIPEH, TELEP, false, ARROW, false, TELEP, PUMP4, TANK4, false},
}
--
@ -525,7 +535,7 @@ local MAGN2 = {"techage_collider_magnet.png^techage_steel_tiles_top3.png^[transf
local MAGN3 = {"techage_collider_magnet.png^techage_steel_tiles_top3.png^[transformR180]", "techage:ta5_magnet1"}
local MAGN4 = {"techage_collider_magnet.png^techage_steel_tiles_top3.png^[transformR270]", "techage:ta5_magnet1"}
techage.ConstructionPlans["ta5_fusion_reactor"] = {
plans["ta5_fusion_reactor"] = {
{false, false, false, false, false, false, IMG46, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false, false, false, false},
@ -549,7 +559,7 @@ local HEX53 = {"techage_filling_ta4.png^techage_frameB_ta4.png^techage_appl_hole
local TURB5 = {"techage_filling_ta4.png^techage_appl_turbine.png^techage_frame_ta5.png", "techage:ta5_turbine"}
local GENE5 = {"techage_filling_ta4.png^techage_frame_ta5.png^techage_appl_generator.png^[transformFX]", "techage:ta5_generator"}
techage.ConstructionPlans["ta5_heatexchanger"] = {
plans["ta5_heatexchanger"] = {
{false, false, false, false, SIDEV, false, false, false},
{false, false, false, false, false, false, false, false},
{false, false, false, false, false, false, false, false},
@ -560,9 +570,38 @@ techage.ConstructionPlans["ta5_heatexchanger"] = {
{false, false, false, false, false, false, false, false},
}
-- Bring into legacy format
local function reformat(plan)
for y=1,#plan do
for x=1,#plan[1] do
local item = plan[y][x] or false
if item ~= false then
local var1, var2 = item[1], item[2]
function techage.add_manual_plans(table_with_plans)
for name, tbl in pairs(table_with_plans) do
techage.ConstructionPlans[name] = tbl
if var1 == "top_view" then
plan[y][x] = {"text", var1}
elseif var1 == "side_view" then
plan[y][x] = {"text", var1}
elseif var1 == "sectional_view" then
plan[y][x] = {"text", var1}
elseif var1 == "" then
plan[y][x] = {"img", var2, "2.2,2.2"}
elseif var1 == "10x10" then
plan[y][x] = {"img", var2, "10,10"}
elseif var1 == "5x4" then
plan[y][x] = {"img", var2, "5,4"}
else
plan[y][x] = {"item", var1, var2}
end
end
end
end
return plan
end
for name, plan in pairs(plans) do
local plan2 = reformat(plan)
doclib.add_manual_plan("techage", "EN", name, plan2)
doclib.add_manual_plan("techage", "DE", name, plan2)
doclib.add_manual_plan("techage", "pt-BR", name, plan2)
end

View File

@ -66,7 +66,7 @@ minetest.register_node("techage:ta4_generator_on", {
"techage_filling_ta4.png^techage_appl_hole_electric.png^techage_frame_ta4.png",
"techage_filling_ta4.png^techage_appl_open.png^techage_frame_ta4.png",
{
image = "techage_filling4_ta4.png^techage_appl_generator4.png^techage_frame4_ta4.png",
name = "techage_filling4_ta4.png^techage_appl_generator4.png^techage_frame4_ta4.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -76,7 +76,7 @@ minetest.register_node("techage:ta4_generator_on", {
},
},
{
image = "techage_filling4_ta4.png^techage_appl_generator4.png^[transformFX]^techage_frame4_ta4.png",
name = "techage_filling4_ta4.png^techage_appl_generator4.png^[transformFX]^techage_frame4_ta4.png",
backface_culling = false,
animation = {
type = "vertical_frames",

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -27,9 +27,11 @@ local control = networks.control
local CYCLE_TIME = 2
local GRVL_CAPA = 500
local PWR_CAPA = {
[5] = GRVL_CAPA * 3 * 3 * 3, -- 13500 Cyc = 450 min = 22.5 kud
[7] = GRVL_CAPA * 5 * 5 * 5, -- 104 kud
[9] = GRVL_CAPA * 7 * 7 * 7, -- 286 kuh
[5] = GRVL_CAPA * 3 * 3 * 3, -- 13500 Cyc = 450 min = 22.5 kud
[7] = GRVL_CAPA * 5 * 5 * 5, -- 104 kud
[9] = GRVL_CAPA * 7 * 7 * 7, -- 286 kuh
[11] = GRVL_CAPA * 9 * 9 * 9, -- 610 kuh
[13] = GRVL_CAPA * 11 * 11 * 11, -- 1112 kuh
}
local DOWN = 5
local PWR_NEEDED = 5
@ -161,8 +163,10 @@ end
local function check_TES_integrity(pos, nvm)
nvm.ticks = (nvm.ticks or 0) + 1
if (nvm.ticks % 5) == 0 then -- every 10 saec
glowing(pos, nvm, (nvm.capa or 0) / (nvm.capa_max or 1) > 0.8)
if (nvm.ticks % 5) == 0 then -- every 10 sec
if techage.is_running(nvm) then
glowing(pos, nvm, (nvm.capa or 0) / (nvm.capa_max or 1) > 0.8)
end
end
if (nvm.ticks % 30) == 0 then -- every minute
return heatexchanger1_cmnd(pos, "volume")
@ -347,15 +351,47 @@ techage.register_node({"techage:heatexchanger2"}, {
elseif topic == "load" then
return techage.power.percent(nvm.capa_max, nvm.capa)
elseif topic == "on" then
start_node(pos, techage.get_nvm(pos))
State:start(pos, nvm)
return true
elseif topic == "off" then
stop_node(pos, techage.get_nvm(pos))
State:stop(pos, nvm)
return true
else
return "unsupported"
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 1 and payload[1] == 1 then
State:start(pos, nvm)
return 0
elseif topic == 1 and payload[1] == 0 then
State:stop(pos, nvm)
return 0
else
return 2, ""
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 128 then
return 0, techage.get_node_lvm(pos).name
elseif topic == 129 then -- State
if techage.is_running(nvm) then
return 0, {techage.RUNNING}
else
return 0, {techage.STOPPED}
end
elseif topic == 135 then -- Delivered Power
local data = power.get_network_data(pos, Cable, DOWN)
return 0, {data.consumed - data.provided}
elseif topic == 134 then -- Tank Load Percent
local value = techage.power.percent(nvm.capa_max, nvm.capa)
return 0, {math.floor(value + 0.5)}
else
return 2, ""
end
end,
on_node_load = function(pos, node)
local nvm = techage.get_nvm(pos)
if techage.is_running(nvm) then

View File

@ -61,11 +61,15 @@ local Numbers = {
[2] = 96, -- 5x5x2 + 3x5x2 + 3x3x2 - 2
[3] = 216, -- 7x7x2 + 5x7x2 + 5x5x2 - 2
[4] = 384, -- 9x9x2 + 7x9x2 + 7x7x2 - 2
[5] = 600, -- 11x11x2 + 9x11x2 + 9x9x2 - 2
[6] = 864, -- 13x13x2 + 11x13x2 + 11x11x2 - 2
},
filling = {
[2] = 27, -- 3x3x3
[3] = 125, -- 5x5x5
[4] = 343, -- 7x7x7
[5] = 729, -- 9x9x9
[6] = 1331, -- 11x11x11
}
}
@ -101,6 +105,24 @@ local function get_diameter(pos, in_dir)
end
pos2 = vector.add(pos, vector.multiply(dir, 10))
node = minetest.get_node(pos2)
if node.name == "techage:ta3_pipe_wall_entry" then
return
end
if node.name == "techage:ta4_pipe_inlet" then
return 11
end
pos2 = vector.add(pos, vector.multiply(dir, 12))
node = minetest.get_node(pos2)
if node.name == "techage:ta3_pipe_wall_entry" then
return
end
if node.name == "techage:ta4_pipe_inlet" then
return 13
end
pos2 = vector.add(pos, vector.multiply(dir, 14))
local poses = minetest.find_nodes_in_area(pos, pos2, {"techage:ta4_pipe_inlet"})
if #poses > 1 then
return vector.distance(pos, poses[2]) + 1

View File

@ -30,7 +30,7 @@ minetest.register_node("techage:glow_gravel", {
}},
paramtype = "light",
light_source = 8,
groups = {crumbly = 2, falling_node = 1},
groups = {crumbly = 2, falling_node = 1, not_in_creative_inventory = 1},
sounds = default.node_sound_gravel_defaults(),
drop = "",
})

View File

@ -62,7 +62,7 @@ minetest.register_node("techage:ta4_turbine", {
"techage_filling_ta4.png^techage_frame_ta4.png",
"techage_filling_ta4.png^techage_appl_open.png^techage_frame_ta4.png",
"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_hole_pipe.png",
"techage_filling_ta4.png^techage_appl_turbine.png^techage_frame_ta4.png",
"techage_filling_ta4.png^techage_appl_turbine.png^techage_frame_ta4.png^[transformFX",
"techage_filling_ta4.png^techage_appl_turbine.png^techage_frame_ta4.png",
},
@ -92,7 +92,7 @@ minetest.register_node("techage:ta4_turbine_on", {
"techage_filling_ta4.png^techage_appl_open.png^techage_frame_ta4.png",
"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_hole_pipe.png",
{
image = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta4.png",
name = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta4.png^[transformFX",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -102,7 +102,7 @@ minetest.register_node("techage:ta4_turbine_on", {
},
},
{
image = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta4.png",
name = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta4.png",
backface_culling = false,
animation = {
type = "vertical_frames",

View File

@ -74,7 +74,7 @@ for idx,ratio in ipairs(lRatio) do
end
end,
use_texture_alpha = true,
use_texture_alpha = techage.BLEND,
inventory_image = "techage_flame.png",
paramtype = "light",
light_source = 13,

View File

@ -110,7 +110,7 @@ minetest.register_node("techage:ta3_booster_on", {
"techage_filling_ta3.png^techage_appl_hole_pipe.png^techage_frame_ta3.png",
"techage_filling_ta3.png^techage_appl_hole_electric.png^techage_frame_ta3.png",
{
image = "techage_filling4_ta3.png^techage_appl_compressor4.png^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_compressor4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -120,7 +120,7 @@ minetest.register_node("techage:ta3_booster_on", {
},
},
{
image = "techage_filling4_ta3.png^techage_appl_compressor4.png^[transformFX]^techage_frame4_ta3.png",
name = "techage_filling4_ta3.png^techage_appl_compressor4.png^[transformFX]^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -36,11 +36,16 @@ local function stop_firebox(pos, nvm)
M(pos):set_string("formspec", fuel.formspec(nvm))
end
local function furnace_active(pos)
-- Check if furnace is not in standby mode
return techage.get_node_lvm({x=pos.x, y=pos.y+1, z=pos.z}).name == "techage:ta3_furnace_act"
end
local function node_timer(pos, elapsed)
local nvm = techage.get_nvm(pos)
nvm.liquid = nvm.liquid or {}
nvm.liquid.amount = nvm.liquid.amount or 0
if nvm.running then
if nvm.running and furnace_active(pos) then
nvm.burn_cycles = (nvm.burn_cycles or 0) - 1
if nvm.burn_cycles <= 0 then
if nvm.liquid.amount > 0 then
@ -53,6 +58,9 @@ local function node_timer(pos, elapsed)
return false
end
end
else
stop_firebox(pos, nvm)
return false
end
if techage.is_activeformspec(pos) then
M(pos):set_string("formspec", fuel.formspec(nvm))
@ -61,7 +69,8 @@ local function node_timer(pos, elapsed)
end
local function start_firebox(pos, nvm)
if not nvm.running then
if not nvm.running and furnace_active(pos) then
nvm.running = true
node_timer(pos, 0)
firebox.swap_node(pos, "techage:furnace_firebox_on")
@ -105,7 +114,7 @@ minetest.register_node("techage:furnace_firebox", {
on_construct = function(pos)
local nvm = techage.get_nvm(pos)
techage.add_node(pos, "techage:furnace_firebox")
techage.add_node(pos, "techage:furnace_firebox", true)
nvm.running = false
nvm.burn_cycles = 0
nvm.liquid = {}
@ -127,7 +136,7 @@ minetest.register_node("techage:furnace_firebox_on", {
"techage_concrete.png^techage_frame_ta3.png",
"techage_concrete.png^techage_frame_ta3.png",
{
image = "techage_concrete4.png^techage_appl_firehole4.png^techage_frame4_ta3.png",
name = "techage_concrete4.png^techage_appl_firehole4.png^techage_frame4_ta3.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -173,6 +182,18 @@ techage.register_node({"techage:furnace_firebox", "techage:furnace_firebox_on"},
return "unsupported"
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 128 then
return 0, techage.get_node_lvm(pos).name
elseif topic == 129 then -- State
return 0, {nvm.running and techage.RUNNING or techage.STOPPED}
elseif topic == 132 then -- Fuel Level
return 0, {fuel.get_fuel_amount(nvm)}
else
return 2, ""
end
end,
-- called from furnace_top
on_transfer = function(pos, in_dir, topic, payload)
local nvm = techage.get_nvm(pos)

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2020 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -30,7 +30,19 @@ local reset_cooking = techage.furnace.reset_cooking
local get_ingredients = techage.furnace.get_ingredients
local check_if_worth_to_wakeup = techage.furnace.check_if_worth_to_wakeup
local range = techage.in_range
local MP = minetest.get_modpath(minetest.get_current_modname())
local mConf = assert(loadfile(MP .. "/basis/conf_inv.lua"))("cfg")
local WRENCH_MENU3 = {
{
type = "items",
name = "config",
label = S("Pre-Assignment Input Inv."),
tooltip = S("Stack locations can be pre-assigned to specific items,\nto be filled only with those items."),
width = 2,
height = 2,
}
}
local function update_recipe_menu(pos, nvm)
local ingr = get_ingredients(pos)
@ -47,7 +59,9 @@ local function formspec(self, pos, nvm)
default.gui_bg..
default.gui_bg_img..
default.gui_slots..
techage.wrench_image(7.6, -0.2) ..
"list[context;src;0,0;2,2;]"..
mConf.preassigned_stacks(pos, 2, 2)..
"image[2,0.5;1,1;techage_form_arrow_bg.png^[lowpart:"..
(nvm.item_percent or 0)..":techage_form_arrow_fg.png^[transformR270]"..
"image_button[2,2;1,1;".. self:get_state_button_image(nvm) ..";state_button;]"..
@ -237,9 +251,20 @@ local tubing = {
end,
on_push_item = function(pos, in_dir, stack, idx)
local meta = minetest.get_meta(pos)
if meta:get_int("push_dir") == in_dir or in_dir == 5 then
if meta:get_int("push_dir") == in_dir or in_dir == 5 then
local inv = M(pos):get_inventory()
return techage.put_items(inv, "src", stack, idx)
local mem = techage.get_mem(pos)
mem.filter = mem.filter or mConf.item_filter(pos, 4)
mem.chest_configured = mem.chest_configured or not inv:is_empty("cfg")
if mem.chest_configured then
local name = stack:get_name()
local stacks = mem.filter[name] or mem.filter["unconfigured"]
return mConf.put_items(pos, inv, "src", stack, stacks, idx)
else
return techage.put_items(inv, "src", stack, idx)
end
end
end,
on_unpull_item = function(pos, in_dir, stack)
@ -257,6 +282,17 @@ local tubing = {
return CRD(pos).State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return CRD(pos).State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
if topic == 141 then -- Furnace Output
local nvm = techage.get_nvm(pos)
return 0, string.split(nvm.output or "unknown", " ")[1]
else
return CRD(pos).State:on_beduino_request_data(pos, topic, payload)
end
end,
}
local _, node_name_ta3, _ =
@ -272,6 +308,7 @@ local _, node_name_ta3, _ =
local inv = M(pos):get_inventory()
inv:set_size("src", 2*2)
inv:set_size("dst", 2*2)
inv:set_size("cfg", 2*2)
end,
can_dig = can_dig,
node_timer = keep_running,
@ -282,6 +319,8 @@ local _, node_name_ta3, _ =
on_metadata_inventory_put = on_metadata_inventory,
on_metadata_inventory_take = on_metadata_inventory,
on_metadata_inventory_move = on_metadata_inventory,
ta3_formspec = WRENCH_MENU3,
on_rightclick = on_rightclick,
groups = {choppy=2, cracky=2, crumbly=2},
sounds = default.node_sound_wood_defaults(),
num_items = {0,1,1,1},

View File

@ -24,7 +24,7 @@ local power = networks.power
local control = networks.control
local CYCLE_TIME = 2
local STANDBY_TICKS = 0
local STANDBY_TICKS = 1
local COUNTDOWN_TICKS = 1
local PWR_NEEDED = 400
local EXPECTED_PLASMA_NUM = 56
@ -46,6 +46,7 @@ local function count_trues(t)
end
local function nucleus(t)
t = techage.tbl_filter(t, function(v, k, t) return type(v) == "table" end)
if #t == 4 then
if vector.equals(t[1], t[2]) and vector.equals(t[3], t[4]) then
return true
@ -69,7 +70,7 @@ sched.register(tSched, CALL_RATE1, 1, function(pos, outdir)
local resp = control.request(pos, Cable, outdir, "con", "test_plasma")
local cnt = count_trues(resp)
if cnt ~= EXPECTED_PLASMA_NUM then
return S("Tokamak shape error")
return S("Plasma ring shape error")
end
return true
end)
@ -98,11 +99,6 @@ sched.register(tSched, CALL_RATE2, 4, function(pos, outdir)
return true
end)
-- function(pos, outdir)
-- local resp = control.request(pos, Cable, outdir, "con", "no_gas")
-- return "no_gas: " .. concentrate(resp)
-- end,
local function can_start(pos, nvm)
local outdir = networks.side_to_outdir(pos, "L")
if not power.power_available(pos, Cable, outdir) then
@ -221,7 +217,6 @@ minetest.register_node("techage:ta5_fr_controller_pas", {
on_timer = node_timer,
after_dig_node = after_dig_node,
on_receive_fields = on_receive_fields,
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {choppy=2, cracky=2, crumbly=2},
is_ground_content = false,
@ -237,7 +232,7 @@ minetest.register_node("techage:ta5_fr_controller_act", {
"techage_filling_ta4.png^techage_frame_ta5.png^techage_appl_hole_electric.png",
"techage_filling_ta4.png^techage_frame_ta5.png^techage_appl_hole_electric.png",
{
image = "techage_filling4_ta4.png^techage_appl_plasma4.png^techage_frame4_ta5.png",
name = "techage_filling4_ta4.png^techage_appl_plasma4.png^techage_frame4_ta5.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -247,7 +242,7 @@ minetest.register_node("techage:ta5_fr_controller_act", {
},
},
{
image = "techage_filling4_ta4.png^techage_appl_plasma4.png^techage_frame4_ta5.png",
name = "techage_filling4_ta4.png^techage_appl_plasma4.png^techage_frame4_ta5.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -261,7 +256,6 @@ minetest.register_node("techage:ta5_fr_controller_act", {
on_timer = node_timer,
after_dig_node = after_dig_node,
on_receive_fields = on_receive_fields,
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {choppy=2, cracky=2, crumbly=2, not_in_creative_inventory=1},
drop = "",
@ -269,6 +263,18 @@ minetest.register_node("techage:ta5_fr_controller_act", {
sounds = default.node_sound_metal_defaults(),
})
techage.register_node({"techage:ta5_fr_controller_pas", "techage:ta5_fr_controller_act"}, {
on_recv_message = function(pos, src, topic, payload)
return State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return State:on_beduino_request_data(pos, topic, payload)
end,
})
power.register_nodes({"techage:ta5_fr_controller_pas", "techage:ta5_fr_controller_act"}, Cable, "con", {"L", "R"})
minetest.register_craft({
@ -279,3 +285,4 @@ minetest.register_craft({
{'default:steel_ingot', 'default:diamond', 'techage:aluminum'},
},
})

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2022 Joachim Stolberg
Copyright (C) 2019-2023 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -20,8 +20,14 @@ local power = networks.power
local control = networks.control
local CYCLE_TIME = 2
local STANDBY_TICKS = 1
local COUNTDOWN_TICKS = 2
local PWR_PERF = 800
local function formspec(self, pos, nvm)
return techage.generator_formspec(self, pos, nvm, S("TA5 Generator"), nvm.provided, PWR_PERF)
end
local function swap_node(pos, name)
local node = techage.get_node_lvm(pos)
if node.name == name then
@ -31,6 +37,13 @@ local function swap_node(pos, name)
minetest.swap_node(pos, node)
end
local function can_start(pos, nvm, state)
if nvm.alive_cnt and nvm.alive_cnt > 0 then
return true
end
return S("no steam")
end
local function start_node(pos, nvm)
local meta = M(pos)
nvm.provided = 0
@ -38,8 +51,6 @@ local function start_node(pos, nvm)
techage.evaluate_charge_termination(nvm, meta)
local outdir = meta:get_int("outdir")
power.start_storage_calc(pos, Cable, outdir)
swap_node(pos, "techage:ta5_generator_on")
minetest.get_node_timer(pos):start(CYCLE_TIME)
end
local function stop_node(pos, nvm)
@ -47,7 +58,32 @@ local function stop_node(pos, nvm)
nvm.alive_cnt = 0
local outdir = M(pos):get_int("outdir")
power.start_storage_calc(pos, Cable, outdir)
swap_node(pos, "techage:ta5_generator")
end
local State = techage.NodeStates:new({
node_name_passive = "techage:ta5_generator",
node_name_active = "techage:ta5_generator_on",
cycle_time = CYCLE_TIME,
standby_ticks = STANDBY_TICKS,
formspec_func = formspec,
infotext_name = S("TA5 Generator"),
can_start = can_start,
start_node = start_node,
stop_node = stop_node,
})
local function on_receive_fields(pos, formname, fields, player)
if minetest.is_protected(pos, player:get_player_name()) then
return
end
local nvm = techage.get_nvm(pos)
State:state_button_event(pos, nvm, fields)
end
local function on_rightclick(pos, node, clicker)
local nvm = techage.get_nvm(pos)
techage.set_activeformspec(pos, clicker)
M(pos):set_string("formspec", formspec(State, pos, nvm))
end
local function get_generator_data(pos, outdir, tlib2)
@ -59,8 +95,15 @@ end
local function node_timer(pos, elapsed)
local nvm = techage.get_nvm(pos)
local running = techage.is_running(nvm)
nvm.alive_cnt = (nvm.alive_cnt or 0) - 1
if nvm.alive_cnt > 0 then
local alive = nvm.alive_cnt > 0
if running and not alive then
State:standby(pos, nvm, S("no steam"))
stop_node(pos, nvm, State)
elseif not running and alive then
State:start(pos, nvm)
elseif running then
local meta = M(pos)
local outdir = meta:get_int("outdir")
local tp1 = tonumber(meta:get_string("termpoint1"))
@ -70,12 +113,12 @@ local function node_timer(pos, elapsed)
if val > 0 then
nvm.load = val
end
return true
else
swap_node(pos, "techage:ta5_generator")
stop_node(pos, nvm)
return false
State:keep_running(pos, nvm, COUNTDOWN_TICKS)
end
if techage.is_activeformspec(pos) then
M(pos):set_string("formspec", formspec(State, pos, nvm))
end
return State:is_active(nvm)
end
minetest.register_node("techage:ta5_generator", {
@ -91,7 +134,11 @@ minetest.register_node("techage:ta5_generator", {
},
after_place_node = function(pos, placer)
local nvm = techage.get_nvm(pos)
local number = techage.add_node(pos, "techage:ta5_generator")
State:node_init(pos, nvm, number)
M(pos):set_int("outdir", networks.side_to_outdir(pos, "R"))
M(pos):set_string("formspec", formspec(State, pos, nvm))
Cable:after_place_node(pos)
end,
after_dig_node = function(pos, oldnode)
@ -101,6 +148,8 @@ minetest.register_node("techage:ta5_generator", {
get_generator_data = get_generator_data,
ta4_formspec = techage.generator_settings("ta4", PWR_PERF),
on_receive_fields = on_receive_fields,
on_rightclick = on_rightclick,
paramtype2 = "facedir",
groups = {cracky=2, crumbly=2, choppy=2},
on_rotate = screwdriver.disallow,
@ -117,7 +166,7 @@ minetest.register_node("techage:ta5_generator_on", {
"techage_filling_ta4.png^techage_appl_hole_electric.png^techage_frame_ta5.png",
"techage_filling_ta4.png^techage_appl_open.png^techage_frame_ta5.png",
{
image = "techage_filling4_ta4.png^techage_appl_generator4.png^techage_frame4_ta5.png",
name = "techage_filling4_ta4.png^techage_appl_generator4.png^techage_frame4_ta5.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -127,7 +176,7 @@ minetest.register_node("techage:ta5_generator_on", {
},
},
{
image = "techage_filling4_ta4.png^techage_appl_generator4.png^[transformFX]^techage_frame4_ta5.png",
name = "techage_filling4_ta4.png^techage_appl_generator4.png^[transformFX]^techage_frame4_ta5.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -140,6 +189,8 @@ minetest.register_node("techage:ta5_generator_on", {
get_generator_data = get_generator_data,
ta4_formspec = techage.generator_settings("ta4", PWR_PERF),
on_receive_fields = on_receive_fields,
on_rightclick = on_rightclick,
on_timer = node_timer,
paramtype2 = "facedir",
drop = "",
@ -159,17 +210,40 @@ techage.register_node({"techage:ta5_generator", "techage:ta5_generator_on"}, {
if topic == "trigger" then
nvm.alive_cnt = 5
elseif topic == "start" then
start_node(pos, nvm)
--start_node(pos, nvm)
elseif topic == "stop" then
stop_node(pos, nvm)
end
end,
on_recv_message = function(pos, src, topic, payload)
return "unsupported"
local nvm = techage.get_nvm(pos)
if topic == "delivered" then
return nvm.provided or 0
else
return State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 135 then
return 0, {nvm.provided or 0}
else
return State:on_beduino_request_data(pos, topic, payload)
end
end,
on_node_load = function(pos)
-- remove legacy formspec
M(pos):set_string("formspec", "")
-- Add node number if missing
local number = M(pos):get_string("node_number")
if number == "" then
local nvm = techage.get_nvm(pos)
local number = techage.add_node(pos, "techage:ta5_generator")
State:node_init(pos, nvm, number)
State:start(pos, nvm)
M(pos):set_string("formspec", formspec(State, pos, nvm))
end
end,
})

View File

@ -91,7 +91,7 @@ techage.register_node({"techage:ta5_heatexchanger1"}, {
on_transfer = function(pos, indir, topic, payload)
local nvm = techage.get_nvm(pos)
-- used by heatexchanger2
if topic == "test_gas_blue" then
if topic == "test_pipe_blue" or topic == "test_gas_blue" then
return control_cmnd(pos, topic)
else
return turbine_cmnd(pos, topic, payload)

View File

@ -93,7 +93,10 @@ sched.register(tSched, CALL_RATE1, 1, function(pos)
return true
end)
sched.register(tSched, CALL_RATE1, 2, function(pos)
local resp = heatexchanger1_cmnd(pos, "test_gas_blue")
local resp = heatexchanger1_cmnd(pos, "test_pipe_blue")
if type(resp) ~= "table" then
return DESCRIPTION .. S(" Error!")
end
local cnt = count_trues(resp)
if cnt ~= EXPECT_BLUE then
return S("Blue pipe connection error\n(@1 found / @2 expected)", cnt, EXPECT_BLUE)
@ -101,14 +104,30 @@ sched.register(tSched, CALL_RATE1, 2, function(pos)
return true
end)
sched.register(tSched, CALL_RATE1, 3, function(pos)
local resp = heatexchanger3_cmnd(pos, "test_gas_green")
local resp = heatexchanger3_cmnd(pos, "test_pipe_green")
local cnt = count_trues(resp)
if cnt ~= EXPECT_GREEN then
return S("Green pipe connection error\n(@1 found / @2 expected)", cnt, EXPECT_GREEN)
end
return true
end)
sched.register(tSched, CALL_RATE2, 4, function(pos)
sched.register(tSched, CALL_RATE1, 4, function(pos)
local resp = heatexchanger1_cmnd(pos, "test_gas_blue")
local cnt = count_trues(resp)
if cnt ~= EXPECT_BLUE then
return S("Blue pipe coolant missing\n(@1 found / @2 expected)", cnt, EXPECT_BLUE)
end
return true
end)
sched.register(tSched, CALL_RATE1, 5, function(pos)
local resp = heatexchanger3_cmnd(pos, "test_gas_green")
local cnt = count_trues(resp)
if cnt ~= EXPECT_GREEN then
return S("Green pipe coolant missing\n(@1 found / @2 expected)", cnt, EXPECT_GREEN)
end
return true
end)
sched.register(tSched, CALL_RATE2, 6, function(pos)
local resp = heatexchanger3_cmnd(pos, "dec_power")
local cnt = count_trues(resp)
--print("dec_power", cnt)
@ -123,7 +142,7 @@ local function can_start(pos, nvm)
return S("No power")
end
heatexchanger3_cmnd(pos, "rst_power")
for i = 0,4 do
for i = 0,6 do
local res = tSched[i](pos)
if res ~= true and res ~= 1 then return res end
end
@ -167,7 +186,7 @@ local State = techage.NodeStates:new({
node_name_passive = "techage:ta5_heatexchanger2",
cycle_time = CYCLE_TIME,
infotext_name = DESCRIPTION,
standby_ticks = 0,
standby_ticks = 1,
can_start = can_start,
start_node = start_node,
stop_node = stop_node,
@ -183,7 +202,7 @@ local function steam_management(pos, nvm)
nvm.temperature = math.min(nvm.temperature + 10, 100)
elseif resp ~= true then
State:fault(pos, nvm, resp)
stop_node(pos, nvm)
State:stop(pos, nvm)
return false
end
@ -325,15 +344,44 @@ techage.register_node({"techage:ta5_heatexchanger2"}, {
local data = power.get_network_data(pos, Cable, DOWN)
return data.consumed - data.provided
elseif topic == "on" then
start_node(pos, techage.get_nvm(pos))
State:start(pos, nvm)
return true
elseif topic == "off" then
stop_node(pos, techage.get_nvm(pos))
State:stop(pos, nvm)
return true
else
return "unsupported"
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 1 and payload[1] == 1 then
start_node(pos, techage.get_nvm(pos))
return 0
elseif topic == 1 and payload[1] == 0 then
stop_node(pos, techage.get_nvm(pos))
return 0
else
return 2, ""
end
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 128 then
return 0, techage.get_node_lvm(pos).name
elseif topic == 129 then -- State
if techage.is_running(nvm) then
return 0, {techage.RUNNING}
else
return 0, {techage.STOPPED}
end
elseif topic == 135 then -- Delivered Power
local data = power.get_network_data(pos, Cable, DOWN)
return 0, {data.consumed - data.provided}
else
return 2, ""
end
end,
on_node_load = function(pos, node)
local nvm = techage.get_nvm(pos)
if techage.is_running(nvm) then
@ -344,7 +392,7 @@ techage.register_node({"techage:ta5_heatexchanger2"}, {
-- Attempt to restart the system as the heat exchanger goes into error state
-- when parts of the storage block are unloaded.
if nvm.techage_state == techage.FAULT then
start_node(pos, nvm)
State:start(pos, nvm)
end
end,
})

View File

@ -54,7 +54,6 @@ minetest.register_node("techage:ta5_magnet1", {
Cable:after_dig_node(pos)
techage.del_mem(pos)
end,
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {choppy=2, cracky=2, crumbly=2},
is_ground_content = false,
@ -88,7 +87,6 @@ minetest.register_node("techage:ta5_magnet2", {
Cable:after_dig_node(pos)
techage.del_mem(pos)
end,
drawtype = "nodebox",
paramtype2 = "facedir",
groups = {choppy=2, cracky=2, crumbly=2},
is_ground_content = false,
@ -200,6 +198,13 @@ local function on_request(pos, tlib2, topic)
else -- Pipe
if topic == "dec_power" then
return dec_power(nvm)
elseif topic == "test_pipe_blue" then
nvm.test_pipe = true
return true
elseif topic == "test_pipe_green" then
local res = nvm.test_pipe
nvm.test_pipe = false
return res
elseif topic == "test_gas_blue" then
nvm.has_gas = true
return nvm.liquid.amount == CAPACITY

View File

@ -31,6 +31,14 @@ local WRENCH_MENU = {{
name = "flowrate",
label = S("Total flow rate"),
tooltip = S("Total flow rate in liquid units"),
},{
type = "dropdown",
choices = "normal,reverse",
name = "operation",
label = S("Operation"),
tooltip = S("Pump direction"),
values = {0, 1},
default = "1",
}}
local State = techage.NodeStates:new({
@ -43,20 +51,39 @@ local State = techage.NodeStates:new({
local function pumping(pos, nvm)
local outdir = M(pos):get_int("outdir")
local taken, name = liquid.take(pos, Pipe2, Flip[outdir], nil, CAPA)
if taken > 0 then
local leftover = liquid.put(pos, Pipe3, outdir, name, taken)
if leftover and leftover > 0 then
liquid.untake(pos, Pipe2, Flip[outdir], name, leftover)
if leftover == taken then
State:blocked(pos, nvm)
return 0
local reverse = M(pos):get_int("operation")
if reverse == 1 then
local taken, name = liquid.take(pos, Pipe3, outdir, nil, CAPA)
if taken > 0 then
local leftover = liquid.put(pos, Pipe2, Flip[outdir], name, taken)
if leftover and leftover > 0 then
liquid.untake(pos, Pipe3, outdir, name, leftover)
if leftover == taken then
State:blocked(pos, nvm)
return 0
end
State:keep_running(pos, nvm, COUNTDOWN_TICKS)
return taken - leftover
end
State:keep_running(pos, nvm, COUNTDOWN_TICKS)
return taken - leftover
return taken
end
else
local taken, name = liquid.take(pos, Pipe2, Flip[outdir], nil, CAPA)
if taken > 0 then
local leftover = liquid.put(pos, Pipe3, outdir, name, taken)
if leftover and leftover > 0 then
liquid.untake(pos, Pipe2, Flip[outdir], name, leftover)
if leftover == taken then
State:blocked(pos, nvm)
return 0
end
State:keep_running(pos, nvm, COUNTDOWN_TICKS)
return taken - leftover
end
State:keep_running(pos, nvm, COUNTDOWN_TICKS)
return taken
end
State:keep_running(pos, nvm, COUNTDOWN_TICKS)
return taken
end
State:idle(pos, nvm)
return 0
@ -113,7 +140,7 @@ local tiles_act = {
"techage_filling_ta4.png^techage_appl_hole_ta5_pipe2.png^techage_frame_ta5.png",
"techage_filling_ta4.png^techage_appl_hole_pipe.png^techage_frame_ta5.png",
{
image = "techage_filling8_ta4.png^techage_appl_pump8.png^techage_frame8_ta5.png^[transformFX",
name = "techage_filling8_ta4.png^techage_appl_pump8.png^techage_frame8_ta5.png^[transformFX",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -123,7 +150,7 @@ local tiles_act = {
},
},
{
image = "techage_filling8_ta4.png^techage_appl_pump8.png^techage_frame8_ta5.png",
name = "techage_filling8_ta4.png^techage_appl_pump8.png^techage_frame8_ta5.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -170,6 +197,12 @@ techage.register_node({"techage:ta5_pump", "techage:ta5_pump_on"}, {
on_recv_message = function(pos, src, topic, payload)
return State:on_receive_message(pos, topic, payload)
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
return State:on_beduino_request_data(pos, topic, payload)
end,
})
-- Pumps have to provide one output and one input side

View File

@ -62,7 +62,7 @@ minetest.register_node("techage:ta5_turbine", {
"techage_filling_ta4.png^techage_frame_ta4_bottom.png",
"techage_filling_ta4.png^techage_appl_open.png^techage_frame_ta5.png",
"techage_filling_ta4.png^techage_frame_ta5.png^techage_appl_hole_pipe.png",
"techage_filling_ta4.png^techage_appl_turbine.png^techage_frame_ta5.png",
"techage_filling_ta4.png^techage_appl_turbine.png^techage_frame_ta5.png^[transformFX",
"techage_filling_ta4.png^techage_appl_turbine.png^techage_frame_ta5.png",
},
@ -92,7 +92,7 @@ minetest.register_node("techage:ta5_turbine_on", {
"techage_filling_ta4.png^techage_appl_open.png^techage_frame_ta5.png",
"techage_filling_ta4.png^techage_frame_ta5.png^techage_appl_hole_pipe.png",
{
image = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta5.png",
name = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta5.png^[transformFX",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -102,7 +102,7 @@ minetest.register_node("techage:ta5_turbine_on", {
},
},
{
image = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta5.png",
name = "techage_filling4_ta4.png^techage_appl_turbine4.png^techage_frame4_ta5.png",
backface_culling = false,
animation = {
type = "vertical_frames",

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -26,6 +26,7 @@ local STANDBY_TICKS = 3
local PWR_NEEDED = 35
local PWR_UNITS_PER_HYDROGEN_ITEM = 80
local CAPACITY = 200
local TURNOFF_THRESHOLD = "40%"
local function evaluate_percent(s)
return (tonumber(s:sub(1, -2)) or 0) / 100
@ -124,11 +125,14 @@ local function node_timer(pos, elapsed)
State:keep_running(pos, nvm, 1)
end
elseif curr_load == 0 then
nvm.taken = 0
State:nopower(pos, nvm)
else
nvm.taken = 0
State:standby(pos, nvm, S("Turnoff point reached"))
end
else
nvm.taken = 0
State:blocked(pos, nvm, S("Storage full"))
end
if techage.is_activeformspec(pos) then
@ -161,6 +165,8 @@ local function after_place_node(pos)
State:node_init(pos, nvm, number)
local node = minetest.get_node(pos)
M(pos):set_int("in_dir", techage.side_to_indir("R", node.param2))
M(pos):set_string("reduction", "100%")
M(pos):set_string("turnoff", TURNOFF_THRESHOLD)
Pipe:after_place_node(pos)
Cable:after_place_node(pos)
end
@ -197,11 +203,11 @@ local tool_config = {
},
{
type = "dropdown",
choices = "0%,20%,40%,60%,80%",
choices = "0%,20%,40%,60%,80%,98%",
name = "turnoff",
label = S("Turnoff point"),
tooltip = S("If the charge of the storage\nsystem exceeds the configured value,\nthe block switches off"),
default = "0%",
tooltip = S("If the charge of the storage\nsystem falls below the configured value,\nthe block switches off"),
default = TURNOFF_THRESHOLD,
},
}
@ -247,7 +253,7 @@ minetest.register_node("techage:ta4_electrolyzer_on", {
"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_hole_pipe.png",
"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_hole_electric.png",
{
image = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_electrolyzer4.png^techage_appl_ctrl_unit4.png^[transformFX",
name = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_electrolyzer4.png^techage_appl_ctrl_unit4.png^[transformFX",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -257,7 +263,7 @@ minetest.register_node("techage:ta4_electrolyzer_on", {
},
},
{
image = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_electrolyzer4.png^techage_appl_ctrl_unit4.png",
name = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_electrolyzer4.png^techage_appl_ctrl_unit4.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -332,11 +338,24 @@ techage.register_node({"techage:ta4_electrolyzer", "techage:ta4_electrolyzer_on"
return State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 134 and payload[1] == 1 then
return 0, {techage.power.percent(CAPACITY, (nvm.liquid and nvm.liquid.amount) or 0)}
elseif topic == 135 then
return 0, {math.floor((nvm.provided or 0) + 0.5)}
else
return State:on_beduino_request_data(pos, topic, payload)
end
end,
on_node_load = function(pos, node)
local meta = M(pos)
if not meta:contains("reduction") then
meta:set_string("reduction", "100%")
meta:set_string("turnoff", "0%")
meta:set_string("turnoff", TURNOFF_THRESHOLD)
end
end,
})

View File

@ -3,7 +3,7 @@
TechAge
=======
Copyright (C) 2019-2021 Joachim Stolberg
Copyright (C) 2019-2022 Joachim Stolberg
AGPL v3
See LICENSE.txt for more information
@ -215,7 +215,7 @@ minetest.register_node("techage:ta4_fuelcell_on", {
"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_hole_electric.png",
"techage_filling_ta4.png^techage_frame_ta4.png^techage_appl_hole_pipe.png",
{
image = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_fuelcell4.png^techage_appl_ctrl_unit4.png^[transformFX",
name = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_fuelcell4.png^techage_appl_ctrl_unit4.png^[transformFX",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -225,7 +225,7 @@ minetest.register_node("techage:ta4_fuelcell_on", {
},
},
{
image = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_fuelcell4.png^techage_appl_ctrl_unit4.png",
name = "techage_filling4_ta4.png^techage_frame4_ta4.png^techage_appl_fuelcell4.png^techage_appl_ctrl_unit4.png",
backface_culling = false,
animation = {
type = "vertical_frames",
@ -304,6 +304,19 @@ techage.register_node({"techage:ta4_fuelcell", "techage:ta4_fuelcell_on"}, {
return State:on_receive_message(pos, topic, payload)
end
end,
on_beduino_receive_cmnd = function(pos, src, topic, payload)
return State:on_beduino_receive_cmnd(pos, topic, payload)
end,
on_beduino_request_data = function(pos, src, topic, payload)
local nvm = techage.get_nvm(pos)
if topic == 134 and payload[1] == 1 then
return 0, {techage.power.percent(CAPACITY, (nvm.liquid and nvm.liquid.amount) or 0)}
elseif topic == 135 then
return 0, {math.floor((nvm.provided or 0) + 0.5)}
else
return State:on_beduino_request_data(pos, topic, payload)
end
end,
})
control.register_nodes({"techage:ta4_fuelcell", "techage:ta4_fuelcell_on"}, {

Some files were not shown because too many files have changed in this diff Show More