mirrors
/
CC-Tweaked
mirror of https://github.com/SquidDev-CC/CC-Tweaked
1
0
Fork 0
Code Issues Releases Wiki Activity
CC-Tweaked/projects/common/src/main/java/dan200/computercraft/shared/command/CommandComputerCraft.java

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

433 lines
18 KiB
Java
Raw Normal View History

License CC:T according to the REUSE specification (#1351) This adds SPDX license headers to all source code files, following the REUSE[1] specification. This does not include any asset files (such as generated JSON files, or textures). While REUSE does support doing so with ".license" files, for now we define these licences using the .reuse/dep5 file. [1]: https://reuse.software/
2023-03-15 21:52:13 +00:00
// SPDX-FileCopyrightText: 2017 The CC: Tweaked Developers
//
// SPDX-License-Identifier: MPL-2.0
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
package dan200.computercraft.shared.command;
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.arguments.StringArgumentType;
Several command permission fixes - Attach permission checks to the first argument (so the literal command name) rather than the last argument. This fixes commands showing up when they shouldn't. - HelpingArgumentBuilder now inherits permissions of its leaf nodes. This only really impacts the "track" subcommand. - Don't autocomplete the computer selector for the "queue" subcommand. As everyone has permission for this command, it's possible to find all computer ids and labels in the world. I'm in mixed minds about this, but don't think this is an exploit - computer ids/labels are sent to in-range players so shouldn't be considered secret - but worth patching none-the-less.
2023-07-05 10:38:21 +00:00
import com.mojang.brigadier.builder.RequiredArgumentBuilder;
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
import com.mojang.brigadier.exceptions.CommandSyntaxException;
Several command permission fixes - Attach permission checks to the first argument (so the literal command name) rather than the last argument. This fixes commands showing up when they shouldn't. - HelpingArgumentBuilder now inherits permissions of its leaf nodes. This only really impacts the "track" subcommand. - Don't autocomplete the computer selector for the "queue" subcommand. As everyone has permission for this command, it's possible to find all computer ids and labels in the world. I'm in mixed minds about this, but don't think this is an exploit - computer ids/labels are sent to in-range players so shouldn't be considered secret - but worth patching none-the-less.
2023-07-05 10:38:21 +00:00
import com.mojang.brigadier.suggestion.Suggestions;
Convert computer sides to an enum Previously we just relied on magic int values, which was confusing and potentially error-prone. We could use EnumFacing, but that's a) dependent on MC and b) incorrect, as we're referring to local coordinates.
2019-04-09 09:02:54 +00:00
import dan200.computercraft.core.computer.ComputerSide;
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
import dan200.computercraft.core.metrics.Metrics;
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
import dan200.computercraft.shared.ModRegistry;
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
import dan200.computercraft.shared.command.arguments.ComputerArgumentType;
import dan200.computercraft.shared.command.arguments.ComputerSelector;
Move from FMLEventChannel to SimpleNetworkWrapper - Split each network packet into it's own individual IMessage class. - Move the TextTable into separate classes for server and client based rendering.
2018-12-29 12:18:05 +00:00
import dan200.computercraft.shared.command.text.TableBuilder;
Move the /computer command into the main computercraft command I don't think anyone has actually ended up using this, so it's unlikely to break anything (though do tell me if this is the case). On the flip side, this allows us to queue events on multiple computers, and means we can provide a little more documentation.
2018-11-29 11:57:52 +00:00
import dan200.computercraft.shared.computer.core.ComputerFamily;
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
import dan200.computercraft.shared.computer.core.ServerComputer;
Start work on curtailing our global state The last 4 or 5 commits have simplified things. I can now have some unnecessary complexity as a treat! This is some initial work on better tying the lifecycle of computers (and ComputerCraft) related state to the lifecycle of the current Minecraft server. - Move server-wide methods in IComputerEnvironment (such as creating resource mounts) into a separate interface. - Add a new ServerContext class, which now holds the ID Assigner, server computer registry, and some other tiny bits and bobs. This can only be accessed by ServerContect.get(MinecraftServer), forcing slightly better discipline for how we use these globals. This does allow us to nuke some of the ugliest bits in IDAssigner. Even if it makes things much longer!
2022-10-21 20:01:01 +00:00
import dan200.computercraft.shared.computer.core.ServerContext;
Split CC:T into common and forge projects After several weeks of carefully arranging ribbons, we pull the string and end up with, ... a bit of a messy bow. There were still some things I'd missed. - Split the mod into a common (vanilla-only) project and Forge-specific project. This gives us room to add Fabric support later on. - Split the project into main/client source sets. This is not currently statically checked: we'll do that soon. - Rename block/item/tile entities to use suffixes rather than prefixes.
2022-11-09 23:58:56 +00:00
import dan200.computercraft.shared.computer.inventory.ViewComputerMenu;
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
import dan200.computercraft.shared.computer.metrics.basic.Aggregate;
import dan200.computercraft.shared.computer.metrics.basic.AggregatedMetric;
import dan200.computercraft.shared.computer.metrics.basic.BasicComputerMetricsObserver;
import dan200.computercraft.shared.computer.metrics.basic.ComputerMetrics;
Remove ClientComputer Historically CC has maintained two computer registries; one on the server (which runs the actual computer) and one on the client (which stores the terminal and some small bits of additional data). This means when a user opens the computer UI, we send the terminal contents and store it in the client computer registry. We then send the instance id alongside the "open container" packet, which is used to look up the client computer (and thus terminal) in our client-side registry. This patch makes the computer menu syncing behaviour more consistent with vanilla. The initial terminal contents is sent alongside the "open container" packet, and subsequent terminal changes apply /just/ to the open container. Computer on/off state is synced via a vanilla ContainerData/IIntArray. Likewise, sending user input to the server now targets the open container, rather than an arbitrary instance id. The one remaining usage of ClientComputer is for pocket computers. For these, we still need to sync the current on/off/blinking state and the pocket computer light. We don't need the full ClientComputer interface for this case (after all, you can't send input to a pocket computer someone else is holding!). This means we can tear out ClientComputer and ClientComputerRegistry, replacing it with a much simpler ClientPocketComputers store. This in turn allows the following changes: - Remove IComputer, as we no longer need to abstract over client and server computers. - Likewise, we can merge ComputerRegistry into the server registry. This commit also cleans up the handling of instance IDs a little bit: ServerComputers are now responsible for generating their ID and adding/removing themselves from the registry. - As the client-side terminal will never be null, we can remove a whole bunch of null checks throughout the codebase. - As the terminal is available immediately, we don't need to explicitly pass in terminal sizes to the computer GUIs. This means we're no longer reliant on those config values on the client side! - Remove the "request computer state" packet. Pocket computers now store which players need to know the computer state, automatically sending data when a new player starts tracking the computer.
2022-10-21 17:17:42 +00:00
import dan200.computercraft.shared.network.container.ComputerContainerData;
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
import net.minecraft.ChatFormatting;
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.core.BlockPos;
import net.minecraft.network.chat.Component;
import net.minecraft.world.MenuProvider;
Update to 1.19.4 (#1376)
2023-03-15 21:04:11 +00:00
import net.minecraft.world.entity.RelativeMovement;
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
Merge branch 'mc-1.16.x' into mc-1.18.x
2022-10-30 08:49:52 +00:00
import net.minecraft.world.item.ItemStack;
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
import net.minecraft.world.level.Level;
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
import net.minecraft.world.phys.Vec3;
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
Make the main mod non-null by default This was actually much more work than I thought it would be. Tests pass, but I'm sure there's some regressions in here.
2022-11-09 18:58:31 +00:00
import javax.annotation.Nullable;
Add button to view computer's folder Implementation is a little awkward, as we can't send OPEN_FILE links from the server, so we ensure the client runs a /computercraft open-computer ID command instead. We then intercept this on the client side and use that to open the folder.
2021-05-28 21:19:04 +00:00
import java.io.File;
Add computer performance monitor
2018-02-02 13:34:27 +00:00
import java.util.*;
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
import static dan200.computercraft.shared.command.CommandUtils.isPlayer;
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
import static dan200.computercraft.shared.command.Exceptions.NOT_TRACKING_EXCEPTION;
import static dan200.computercraft.shared.command.Exceptions.NO_TIMINGS_EXCEPTION;
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
import static dan200.computercraft.shared.command.arguments.TrackingFieldArgumentType.metric;
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
import static dan200.computercraft.shared.command.builder.CommandBuilder.args;
import static dan200.computercraft.shared.command.builder.CommandBuilder.command;
import static dan200.computercraft.shared.command.builder.HelpingArgumentBuilder.choice;
Move from FMLEventChannel to SimpleNetworkWrapper - Split each network packet into it's own individual IMessage class. - Move the TextTable into separate classes for server and client based rendering.
2018-12-29 12:18:05 +00:00
import static dan200.computercraft.shared.command.text.ChatHelpers.*;
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
import static net.minecraft.commands.Commands.literal;
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
public final class CommandComputerCraft {
Various improvements to the tracking system - Trackers are created per-user, meaning multiple people can run /computercraft track at once. - Allow sorting the tracking information by arbitrary fields. - Add support for tracking arbitrary fields (though none are currently implemented).
2018-04-16 20:06:16 +00:00
public static final UUID SYSTEM_UUID = new UUID(0, 0);
Use client-side commands for opening computer folders Forge doesn't run client-side commands from sendUnsignedCommand, so we still require a mixin there. We do need to change the command name, as Fabric doesn't properly merge the two command trees.
2024-01-30 22:00:36 +00:00
/**
* The client-side command to open the folder. Ideally this would live under the main {@code computercraft}
* namespace, but unfortunately that overrides commands, rather than merging them.
*/
public static final String CLIENT_OPEN_FOLDER = "computercraft-computer-folder";
Various improvements to the tracking system - Trackers are created per-user, meaning multiple people can run /computercraft track at once. - Allow sorting the tracking information by arbitrary fields. - Add support for tracking arbitrary fields (though none are currently implemented).
2018-04-16 20:06:16 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
private CommandComputerCraft() {
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
}
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
dispatcher.register(choice("computercraft")
.then(literal("dump")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
.requires(ModRegistry.Permissions.PERMISSION_DUMP)
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
.executes(c -> dump(c.getSource()))
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(args()
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
.arg("computer", ComputerArgumentType.get())
.executes(c -> dumpComputer(c.getSource(), ComputerArgumentType.getOne(c, "computer")))))
Reformat everything - Switch to a fairly standard code format. This is largely based on IntelliJ defaults, with some minor tweaks applied via editor config. Should mean people don't need to import a config! - Use "var" everywhere instead of explicit types. Type inference is a joy, and I intend to use it to its fullest. - Start using switch expressions: we couldn't use them before because IntelliJ does silly things with our previous brace style, but now we have the luxury of them!
2022-11-03 23:43:14 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(command("shutdown")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
.requires(ModRegistry.Permissions.PERMISSION_SHUTDOWN)
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
.argManyValue("computers", ComputerArgumentType.get(), ComputerSelector.all())
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
.executes((c, a) -> shutdown(c.getSource(), unwrap(c.getSource(), a))))
Reformat everything - Switch to a fairly standard code format. This is largely based on IntelliJ defaults, with some minor tweaks applied via editor config. Should mean people don't need to import a config! - Use "var" everywhere instead of explicit types. Type inference is a joy, and I intend to use it to its fullest. - Start using switch expressions: we couldn't use them before because IntelliJ does silly things with our previous brace style, but now we have the luxury of them!
2022-11-03 23:43:14 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(command("turn-on")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
.requires(ModRegistry.Permissions.PERMISSION_TURN_ON)
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
.argManyValue("computers", ComputerArgumentType.get(), ComputerSelector.all())
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
.executes((c, a) -> turnOn(c.getSource(), unwrap(c.getSource(), a))))
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(command("tp")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
.requires(ModRegistry.Permissions.PERMISSION_TP)
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
.arg("computer", ComputerArgumentType.get())
.executes(c -> teleport(c.getSource(), ComputerArgumentType.getOne(c, "computer"))))
Reformat everything - Switch to a fairly standard code format. This is largely based on IntelliJ defaults, with some minor tweaks applied via editor config. Should mean people don't need to import a config! - Use "var" everywhere instead of explicit types. Type inference is a joy, and I intend to use it to its fullest. - Start using switch expressions: we couldn't use them before because IntelliJ does silly things with our previous brace style, but now we have the luxury of them!
2022-11-03 23:43:14 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(command("queue")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
.requires(ModRegistry.Permissions.PERMISSION_QUEUE)
Several command permission fixes - Attach permission checks to the first argument (so the literal command name) rather than the last argument. This fixes commands showing up when they shouldn't. - HelpingArgumentBuilder now inherits permissions of its leaf nodes. This only really impacts the "track" subcommand. - Don't autocomplete the computer selector for the "queue" subcommand. As everyone has permission for this command, it's possible to find all computer ids and labels in the world. I'm in mixed minds about this, but don't think this is an exploit - computer ids/labels are sent to in-range players so shouldn't be considered secret - but worth patching none-the-less.
2023-07-05 10:38:21 +00:00
.arg(
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
RequiredArgumentBuilder.<CommandSourceStack, ComputerSelector>argument("computer", ComputerArgumentType.get())
Several command permission fixes - Attach permission checks to the first argument (so the literal command name) rather than the last argument. This fixes commands showing up when they shouldn't. - HelpingArgumentBuilder now inherits permissions of its leaf nodes. This only really impacts the "track" subcommand. - Don't autocomplete the computer selector for the "queue" subcommand. As everyone has permission for this command, it's possible to find all computer ids and labels in the world. I'm in mixed minds about this, but don't think this is an exploit - computer ids/labels are sent to in-range players so shouldn't be considered secret - but worth patching none-the-less.
2023-07-05 10:38:21 +00:00
.suggests((context, builder) -> Suggestions.empty())
)
Replace Collections methods with {List,Map,Set}.of The two implementations aren't entirely compatible - the implementation returned by .of will throw an NPE on .contains(null), whereas the Collections implementations just return false. However, we try to avoid passing null to collections methods, so this should be safe. There's no strong reason to do this, but it helps make the code a little more consistent
2023-10-21 09:37:43 +00:00
.argManyValue("args", StringArgumentType.string(), List.of())
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
.executes((c, a) -> queue(ComputerArgumentType.getMany(c, "computer"), a)))
Reformat everything - Switch to a fairly standard code format. This is largely based on IntelliJ defaults, with some minor tweaks applied via editor config. Should mean people don't need to import a config! - Use "var" everywhere instead of explicit types. Type inference is a joy, and I intend to use it to its fullest. - Start using switch expressions: we couldn't use them before because IntelliJ does silly things with our previous brace style, but now we have the luxury of them!
2022-11-03 23:43:14 +00:00
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(command("view")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
.requires(ModRegistry.Permissions.PERMISSION_VIEW)
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
.arg("computer", ComputerArgumentType.get())
.executes(c -> view(c.getSource(), ComputerArgumentType.getOne(c, "computer"))))
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(choice("track")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
.requires(ModRegistry.Permissions.PERMISSION_TRACK)
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
.then(command("start").executes(c -> trackStart(c.getSource())))
.then(command("stop").executes(c -> trackStop(c.getSource())))
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
.then(command("dump")
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
.argManyValue("fields", metric(), DEFAULT_FIELDS)
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
.executes((c, f) -> trackDump(c.getSource(), f))))
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
);
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
}
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
/**
* Display loaded computers to a table.
*
* @param source The thing that executed this command.
* @return The number of loaded computers.
*/
private static int dump(CommandSourceStack source) {
var table = new TableBuilder("DumpAll", "Computer", "On", "Position");
List<ServerComputer> computers = new ArrayList<>(ServerContext.get(source.getServer()).registry().getComputers());
Level world = source.getLevel();
var pos = BlockPos.containing(source.getPosition());
// Sort by nearby computers.
computers.sort((a, b) -> {
if (a.getLevel() == b.getLevel() && a.getLevel() == world) {
return Double.compare(a.getPosition().distSqr(pos), b.getPosition().distSqr(pos));
} else if (a.getLevel() == world) {
return -1;
} else if (b.getLevel() == world) {
return 1;
} else {
Replace integer instance IDs with UUIDs Here's a fun bug you can try at home: - Create a new world - Spawn in a pocket computer, turn it on, and place it in a chest. - Reload the world - the pocket computer in the chest should now be off. - Spawn in a new pocket computer, and turn it on. The computer in chest will also appear to be on! This bug has been present since pocket computers were added (27th March, 2024). When a pocket computer is added to a player's inventory, it is assigned a unique *per-session* "instance id" , which is used to find the associated computer. Note the "per-session" there - these ids will be reused if you reload the world (or restart the server). In the above bug, we see the following: - The first pocket computer is assigned an instance id of 0. - After reloading, the second pocket computer is assigned an instance id of 0. - If the first pocket computer was in our inventory, it'd be ticked and assigned a new instance id. However, because it's in an inventory, it keeps its old one. - Both computers look up their client-side computer state and get the same value, meaning the first pocket computer mirrors the second! To fix this, we now ensure instance ids are entirely unique (not just per-session). Rather than sequentially assigning an int, we now use a random UUID (we probably could get away with a random long, but this feels more idiomatic). This has a couple of user-visible changes: - /computercraft no longer lists instance ids outside of dumping an individual computer. - The @c[instance=...] selector uses UUIDs. We still use int instance ids for the legacy selector, but that'll be removed in a later MC version. - Pocket computers now store a UUID rather than an int. Related to this change (I made this change first, but then they got kinda mixed up together), we now only create PocketComputerData when receiving server data. This makes the code a little uglier in some places (the data may now be null), but means we don't populate the client-side pocket computer map with computers the server doesn't know about.
2024-03-17 12:21:21 +00:00
return a.getInstanceUUID().compareTo(b.getInstanceUUID());
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
}
});
for (var computer : computers) {
table.row(
linkComputer(source, computer, computer.getID()),
bool(computer.isOn()),
linkPosition(source, computer)
);
}
table.display(source);
return computers.size();
}
/**
* Display additional information about a single computer.
*
* @param source The thing that executed this command.
* @param computer The computer we're dumping.
* @return The constant {@code 1}.
*/
private static int dumpComputer(CommandSourceStack source, ServerComputer computer) {
var table = new TableBuilder("Dump");
Replace integer instance IDs with UUIDs Here's a fun bug you can try at home: - Create a new world - Spawn in a pocket computer, turn it on, and place it in a chest. - Reload the world - the pocket computer in the chest should now be off. - Spawn in a new pocket computer, and turn it on. The computer in chest will also appear to be on! This bug has been present since pocket computers were added (27th March, 2024). When a pocket computer is added to a player's inventory, it is assigned a unique *per-session* "instance id" , which is used to find the associated computer. Note the "per-session" there - these ids will be reused if you reload the world (or restart the server). In the above bug, we see the following: - The first pocket computer is assigned an instance id of 0. - After reloading, the second pocket computer is assigned an instance id of 0. - If the first pocket computer was in our inventory, it'd be ticked and assigned a new instance id. However, because it's in an inventory, it keeps its old one. - Both computers look up their client-side computer state and get the same value, meaning the first pocket computer mirrors the second! To fix this, we now ensure instance ids are entirely unique (not just per-session). Rather than sequentially assigning an int, we now use a random UUID (we probably could get away with a random long, but this feels more idiomatic). This has a couple of user-visible changes: - /computercraft no longer lists instance ids outside of dumping an individual computer. - The @c[instance=...] selector uses UUIDs. We still use int instance ids for the legacy selector, but that'll be removed in a later MC version. - Pocket computers now store a UUID rather than an int. Related to this change (I made this change first, but then they got kinda mixed up together), we now only create PocketComputerData when receiving server data. This makes the code a little uglier in some places (the data may now be null), but means we don't populate the client-side pocket computer map with computers the server doesn't know about.
2024-03-17 12:21:21 +00:00
table.row(header("Instance UUID"), text(computer.getInstanceUUID().toString()));
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
table.row(header("Id"), text(Integer.toString(computer.getID())));
table.row(header("Label"), text(computer.getLabel()));
table.row(header("On"), bool(computer.isOn()));
table.row(header("Position"), linkPosition(source, computer));
table.row(header("Family"), text(computer.getFamily().toString()));
for (var side : ComputerSide.values()) {
var peripheral = computer.getPeripheral(side);
if (peripheral != null) {
table.row(header("Peripheral " + side.getName()), text(peripheral.getType()));
}
}
table.display(source);
return 1;
}
/**
* Shutdown a list of computers.
*
* @param source The thing that executed this command.
* @param computers The computers to shutdown.
* @return The constant {@code 1}.
*/
private static int shutdown(CommandSourceStack source, Collection<ServerComputer> computers) {
var shutdown = 0;
for (var computer : computers) {
if (computer.isOn()) shutdown++;
computer.shutdown();
}
var didShutdown = shutdown;
source.sendSuccess(() -> Component.translatable("commands.computercraft.shutdown.done", didShutdown, computers.size()), false);
return shutdown;
}
/**
* Turn on a list of computers.
*
* @param source The thing that executed this command.
* @param computers The computers to turn on.
* @return The constant {@code 1}.
*/
private static int turnOn(CommandSourceStack source, Collection<ServerComputer> computers) {
var on = 0;
for (var computer : computers) {
if (!computer.isOn()) on++;
computer.turnOn();
}
var didOn = on;
source.sendSuccess(() -> Component.translatable("commands.computercraft.turn_on.done", didOn, computers.size()), false);
return on;
}
/**
* Teleport to a computer.
*
* @param source The thing that executed this command. This must be an entity, other types will throw an exception.
* @param computer The computer to teleport to.
* @return The constant {@code 1}.
*/
private static int teleport(CommandSourceStack source, ServerComputer computer) throws CommandSyntaxException {
var world = computer.getLevel();
var pos = Vec3.atBottomCenterOf(computer.getPosition());
source.getEntityOrException().teleportTo(world, pos.x(), pos.y(), pos.z(), EnumSet.noneOf(RelativeMovement.class), 0, 0);
return 1;
}
/**
* Queue a {@code computer_command} event on a command computer.
*
* @param computers The list of computers to queue on.
* @param args The arguments for this event.
* @return The number of computers this event was queued on.
*/
private static int queue(Collection<ServerComputer> computers, List<String> args) {
var rest = args.toArray();
var queued = 0;
for (var computer : computers) {
if (computer.getFamily() == ComputerFamily.COMMAND && computer.isOn()) {
computer.queueEvent("computer_command", rest);
queued++;
}
}
return queued;
}
/**
* Open a terminal for a computer.
*
* @param source The thing that executed this command.
* @param computer The computer to view.
* @return The constant {@code 1}.
*/
private static int view(CommandSourceStack source, ServerComputer computer) throws CommandSyntaxException {
var player = source.getPlayerOrException();
Update to 1.20.5 (#1793) - Switch most network code to use StreamCodec - Turtle/pocket computer upgrades now use DataComponentPatch instead of raw NBT.
2024-04-25 20:32:48 +00:00
new ComputerContainerData(computer, new ItemStack(ModRegistry.Items.COMPUTER_NORMAL.get())).open(player, new MenuProvider() {
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
@Override
public Component getDisplayName() {
return Component.translatable("gui.computercraft.view_computer");
}
@Override
public AbstractContainerMenu createMenu(int id, Inventory player, Player entity) {
return new ViewComputerMenu(id, player, computer);
}
});
return 1;
}
/**
* Start tracking metrics for the current player.
*
* @param source The thing that executed this command.
* @return The constant {@code 1}.
*/
private static int trackStart(CommandSourceStack source) {
getMetricsInstance(source).start();
var stopCommand = "/computercraft track stop";
source.sendSuccess(() -> Component.translatable(
"commands.computercraft.track.start.stop",
link(text(stopCommand), stopCommand, Component.translatable("commands.computercraft.track.stop.action"))
), false);
return 1;
}
/**
* Stop tracking metrics for the current player, displaying a table with the results.
*
* @param source The thing that executed this command.
* @return The constant {@code 1}.
*/
private static int trackStop(CommandSourceStack source) throws CommandSyntaxException {
var metrics = getMetricsInstance(source);
if (!metrics.stop()) throw NOT_TRACKING_EXCEPTION.create();
displayTimings(source, metrics.getSnapshot(), new AggregatedMetric(Metrics.COMPUTER_TASKS, Aggregate.AVG), DEFAULT_FIELDS);
return 1;
}
Replace Collections methods with {List,Map,Set}.of The two implementations aren't entirely compatible - the implementation returned by .of will throw an NPE on .contains(null), whereas the Collections implementations just return false. However, we try to avoid passing null to collections methods, so this should be safe. There's no strong reason to do this, but it helps make the code a little more consistent
2023-10-21 09:37:43 +00:00
private static final List<AggregatedMetric> DEFAULT_FIELDS = List.of(
Move command actions to their own methods Rather than having a mess of lambdas, we now move the bulk of the implemetation to their own methods. The lambdas now just do argument extraction - it's all stringly typed, so good to keep that with the argument definition. This also removes a couple of exception keys (and thus their translation keys) as we no longer use them.
2023-09-05 17:37:10 +00:00
new AggregatedMetric(Metrics.COMPUTER_TASKS, Aggregate.COUNT),
new AggregatedMetric(Metrics.COMPUTER_TASKS, Aggregate.NONE),
new AggregatedMetric(Metrics.COMPUTER_TASKS, Aggregate.AVG)
);
/**
* Display the latest metrics for the current player.
*
* @param source The thing that executed this command.
* @param fields The fields to display in this table, defaulting to {@link #DEFAULT_FIELDS}.
* @return The constant {@code 1}.
*/
private static int trackDump(CommandSourceStack source, List<AggregatedMetric> fields) throws CommandSyntaxException {
AggregatedMetric sort;
if (fields.size() == 1 && DEFAULT_FIELDS.contains(fields.get(0))) {
sort = fields.get(0);
fields = DEFAULT_FIELDS;
} else {
sort = fields.get(0);
}
return displayTimings(source, getMetricsInstance(source).getTimings(), sort, fields);
}
// Additional helper functions.
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
private static Component linkComputer(CommandSourceStack source, @Nullable ServerComputer computer, int computerId) {
Update to Minecraft 1.19 Oh my, a same day release! Well, if we use the AoE timezone. Entirely untested (well, aside from automated tests), I haven't even launched a client. In my defence, its just past midnight and I've been up since 4am.
2022-06-07 23:08:24 +00:00
var out = Component.literal("");
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
// And instance
if (computer == null) {
out.append("#" + computerId + " ").append(coloured("(unloaded)", ChatFormatting.GRAY));
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
} else {
Replace integer instance IDs with UUIDs Here's a fun bug you can try at home: - Create a new world - Spawn in a pocket computer, turn it on, and place it in a chest. - Reload the world - the pocket computer in the chest should now be off. - Spawn in a new pocket computer, and turn it on. The computer in chest will also appear to be on! This bug has been present since pocket computers were added (27th March, 2024). When a pocket computer is added to a player's inventory, it is assigned a unique *per-session* "instance id" , which is used to find the associated computer. Note the "per-session" there - these ids will be reused if you reload the world (or restart the server). In the above bug, we see the following: - The first pocket computer is assigned an instance id of 0. - After reloading, the second pocket computer is assigned an instance id of 0. - If the first pocket computer was in our inventory, it'd be ticked and assigned a new instance id. However, because it's in an inventory, it keeps its old one. - Both computers look up their client-side computer state and get the same value, meaning the first pocket computer mirrors the second! To fix this, we now ensure instance ids are entirely unique (not just per-session). Rather than sequentially assigning an int, we now use a random UUID (we probably could get away with a random long, but this feels more idiomatic). This has a couple of user-visible changes: - /computercraft no longer lists instance ids outside of dumping an individual computer. - The @c[instance=...] selector uses UUIDs. We still use int instance ids for the legacy selector, but that'll be removed in a later MC version. - Pocket computers now store a UUID rather than an int. Related to this change (I made this change first, but then they got kinda mixed up together), we now only create PocketComputerData when receiving server data. This makes the code a little uglier in some places (the data may now be null), but means we don't populate the client-side pocket computer map with computers the server doesn't know about.
2024-03-17 12:21:21 +00:00
out.append(makeComputerDumpCommand(computer));
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
}
// And, if we're a player, some useful links
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
if (computer != null && isPlayer(source)) {
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
if (ModRegistry.Permissions.PERMISSION_TP.test(source)) {
out.append(" ").append(link(
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
text("\u261b"),
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
makeComputerCommand("tp", computer),
Document some of our client classes This is mostly aiming to give an overview rather than be anything comprehensive (there's another 230+ undocumented classes to go :p), but it's a start. Mostly just an excuse for me to procrastinate working on the nasty bugs though!
2023-06-02 20:47:52 +00:00
Component.translatable("commands.computercraft.tp.action")
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
));
}
if (ModRegistry.Permissions.PERMISSION_VIEW.test(source)) {
out.append(" ").append(link(
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
text("\u20e2"),
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
makeComputerCommand("view", computer),
Document some of our client classes This is mostly aiming to give an overview rather than be anything comprehensive (there's another 230+ undocumented classes to go :p), but it's a start. Mostly just an excuse for me to procrastinate working on the nasty bugs though!
2023-06-02 20:47:52 +00:00
Component.translatable("commands.computercraft.view.action")
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
));
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
}
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
}
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
if (isPlayer(source) && UserLevel.isOwner(source)) {
Merge branch 'mc-1.16.x' into mc-1.18.x I dare say there's going to be some bugs with this. I was as careful as I could be, but yikes it was nasty.
2022-10-25 21:36:21 +00:00
var linkPath = linkStorage(source, computerId);
Add button to view computer's folder Implementation is a little awkward, as we can't send OPEN_FILE links from the server, so we ensure the client runs a /computercraft open-computer ID command instead. We then intercept this on the client side and use that to open the folder.
2021-05-28 21:19:04 +00:00
if (linkPath != null) out.append(" ").append(linkPath);
}
Improve using /computercraft as a non-player - Fix text table only showing the first row (fixes #40) - Do not emit alignment characters in monospace environments - Reduce padding in monospace environments Also make the output of dump consistent with that of the profiler: we provide tp and view shortcuts for each computer.
2018-06-22 07:28:36 +00:00
return out;
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
}
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
private static Component linkPosition(CommandSourceStack context, ServerComputer computer) {
Use permission APIs for the /computercraft command - Add a generic PermissionRegistry interface. This behaves similarly to our ShaderMod interface, searching all providers until it finds a compatible one. We could just make this part of the platform code instead, but this allows us to support multiple systems on Fabric, where things are less standardised. This interface behaves like a registry, rather than a straight `getPermission(node, player)` method, as Forge requires us to list our nodes up-front. - Add Forge (using the built-in system) and Fabric (using fabric-permissions-api) implementations of the above interface. - Register permission nodes for our commands, and use those instead. This does mean that the permissions check for the root /computercraft command now requires enumerating all child commands (and so potential does 7 permission lookups), but hopefully this isn't too bad in practice. - Remove UserLevel.OWNER - we never used this anywhere, and I can't imagine we'll want to in the future.
2023-08-27 11:15:55 +00:00
if (ModRegistry.Permissions.PERMISSION_TP.test(context)) {
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
return link(
position(computer.getPosition()),
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
makeComputerCommand("tp", computer),
Document some of our client classes This is mostly aiming to give an overview rather than be anything comprehensive (there's another 230+ undocumented classes to go :p), but it's a start. Mostly just an excuse for me to procrastinate working on the nasty bugs though!
2023-06-02 20:47:52 +00:00
Component.translatable("commands.computercraft.tp.action")
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
);
} else {
return position(computer.getPosition());
}
}
Add computer performance monitor
2018-02-02 13:34:27 +00:00
Make the main mod non-null by default This was actually much more work than I thought it would be. Tests pass, but I'm sure there's some regressions in here.
2022-11-09 18:58:31 +00:00
private static @Nullable Component linkStorage(CommandSourceStack source, int id) {
Start work on curtailing our global state The last 4 or 5 commits have simplified things. I can now have some unnecessary complexity as a treat! This is some initial work on better tying the lifecycle of computers (and ComputerCraft) related state to the lifecycle of the current Minecraft server. - Move server-wide methods in IComputerEnvironment (such as creating resource mounts) into a separate interface. - Add a new ServerContext class, which now holds the ID Assigner, server computer registry, and some other tiny bits and bobs. This can only be accessed by ServerContect.get(MinecraftServer), forcing slightly better discipline for how we use these globals. This does allow us to nuke some of the ugliest bits in IDAssigner. Even if it makes things much longer!
2022-10-21 20:01:01 +00:00
var file = new File(ServerContext.get(source.getServer()).storageDir().toFile(), "computer/" + id);
Add button to view computer's folder Implementation is a little awkward, as we can't send OPEN_FILE links from the server, so we ensure the client runs a /computercraft open-computer ID command instead. We then intercept this on the client side and use that to open the folder.
2021-05-28 21:19:04 +00:00
if (!file.isDirectory()) return null;
STOP DOING MIXINS (on Forge) BYTECODE WAS NOT SUPPOSED TO BE REWRITTEN YEARS OF DEBUGGING REMAPPING FAILURES yet NO ACTUAL SOLUTION FOUND. Wanted to use Mixins for anyway for a laugh? We had a tool for that: it was called "FABRIC LOOM". "Yes, please produce completely broken jars for no discernable reason" Statements dreamed up by the utterly Deranged. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * This removes our two mixins used on Forge: - Breaking progress for cabled/wired modems. - Running client commands from chat click events. We now suggest the command on Forge instead. Occasionally we get issues where the mixin annotation processor doesn't write its tsrg file in time for the reobfJar/reobfJarJar task. I thought we'd fixed that cb8e06af2aefd931b1f6743849a7afb2a25ea0bd, but sometimes we still produce missing jars - I have a feeling this might be to do with incremental compilation. We can maybe re-evaluate this on 1.20.4, where we don't need to worry about remapping any more.
2024-03-21 21:45:17 +00:00
return clientLink(
Add button to view computer's folder Implementation is a little awkward, as we can't send OPEN_FILE links from the server, so we ensure the client runs a /computercraft open-computer ID command instead. We then intercept this on the client side and use that to open the folder.
2021-05-28 21:19:04 +00:00
text("\u270E"),
Use client-side commands for opening computer folders Forge doesn't run client-side commands from sendUnsignedCommand, so we still require a mixin there. We do need to change the command name, as Fabric doesn't properly merge the two command trees.
2024-01-30 22:00:36 +00:00
"/" + CLIENT_OPEN_FOLDER + " " + id,
Document some of our client classes This is mostly aiming to give an overview rather than be anything comprehensive (there's another 230+ undocumented classes to go :p), but it's a start. Mostly just an excuse for me to procrastinate working on the nasty bugs though!
2023-06-02 20:47:52 +00:00
Component.translatable("commands.computercraft.dump.open_path")
Add button to view computer's folder Implementation is a little awkward, as we can't send OPEN_FILE links from the server, so we ensure the client runs a /computercraft open-computer ID command instead. We then intercept this on the client side and use that to open the folder.
2021-05-28 21:19:04 +00:00
);
}
Merge branch 'mc-1.16.x' into mc-1.18.x I dare say there's going to be some bugs with this. I was as careful as I could be, but yikes it was nasty.
2022-10-25 21:36:21 +00:00
private static BasicComputerMetricsObserver getMetricsInstance(CommandSourceStack source) {
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
var entity = source.getEntity();
Merge branch 'mc-1.16.x' into mc-1.18.x I dare say there's going to be some bugs with this. I was as careful as I could be, but yikes it was nasty.
2022-10-25 21:36:21 +00:00
return ServerContext.get(source.getServer()).metrics().getMetricsInstance(entity instanceof Player ? entity.getUUID() : SYSTEM_UUID);
Various improvements to the tracking system - Trackers are created per-user, meaning multiple people can run /computercraft track at once. - Allow sorting the tracking information by arbitrary fields. - Add support for tracking arbitrary fields (though none are currently implemented).
2018-04-16 20:06:16 +00:00
}
Add computer performance monitor
2018-02-02 13:34:27 +00:00
Merge branch 'mc-1.16.x' into mc-1.18.x I dare say there's going to be some bugs with this. I was as careful as I could be, but yikes it was nasty.
2022-10-25 21:36:21 +00:00
private static int displayTimings(CommandSourceStack source, List<ComputerMetrics> timings, AggregatedMetric sortField, List<AggregatedMetric> fields) throws CommandSyntaxException {
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
if (timings.isEmpty()) throw NO_TIMINGS_EXCEPTION.create();
Add computer performance monitor
2018-02-02 13:34:27 +00:00
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
timings.sort(Comparator.<ComputerMetrics, Long>comparing(x -> x.get(sortField.metric(), sortField.aggregate())).reversed());
Various improvements to the tracking system - Trackers are created per-user, meaning multiple people can run /computercraft track at once. - Allow sorting the tracking information by arbitrary fields. - Add support for tracking arbitrary fields (though none are currently implemented).
2018-04-16 20:06:16 +00:00
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
var headers = new Component[1 + fields.size()];
Document some of our client classes This is mostly aiming to give an overview rather than be anything comprehensive (there's another 230+ undocumented classes to go :p), but it's a start. Mostly just an excuse for me to procrastinate working on the nasty bugs though!
2023-06-02 20:47:52 +00:00
headers[0] = Component.translatable("commands.computercraft.track.dump.computer");
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
for (var i = 0; i < fields.size(); i++) headers[i + 1] = fields.get(i).displayName();
Update to 1.19.1
2022-07-28 07:51:10 +00:00
var table = new TableBuilder("Metrics", headers);
Various improvements to the tracking system - Trackers are created per-user, meaning multiple people can run /computercraft track at once. - Allow sorting the tracking information by arbitrary fields. - Add support for tracking arbitrary fields (though none are currently implemented).
2018-04-16 20:06:16 +00:00
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
for (var entry : timings) {
var serverComputer = entry.computer();
Add computer performance monitor
2018-02-02 13:34:27 +00:00
Merge branch 'mc-1.16.x' into mc-1.18.x I dare say there's going to be some bugs with this. I was as careful as I could be, but yikes it was nasty.
2022-10-25 21:36:21 +00:00
var computerComponent = linkComputer(source, serverComputer, entry.computerId());
Error when missing computers after executing the command This allows you to automate running various commands and still have them "work" if some computers are not loaded. Closes #47
2018-08-04 09:39:44 +00:00
Update to Minecraft 1.17.1 - Remap everything to use MojMap class names too. This is what Forge uses, so \o/. This does NOT currently rename any classes to use suffix notation or BlockEntity. That will come in a later change. We do however rename references of "World" to "Level". - Move the test mod into a separate "cctest" source set. As Forge now works using Jigsaw we cannot have multiple mods defining the same package, which causes problems with our JUnit test classes. - Remove our custom test framework and replace it with vanilla's (this is no longer stripped from the jar). RIP kotlin coroutines. It's still worth using Kotlin here though, just for extension methods. - Other 1.17-related changes: - Use separate tile/block entity tick methods for server and client side, often avoiding ticking at all on the client. - Switch much of the monitor rendering code to use vanilla's built-in shader system. It's still an incredibly ugly hack, so not really expecting this to work with any rendering mods, but we'll cross that bridge when we come to it.
2021-08-03 20:46:53 +00:00
var row = new Component[1 + fields.size()];
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
row[0] = computerComponent;
Rewrite the metrics system - Remove TrackingField and replace it with a Metric abstract class. This has two concrete subclasses - Counter and Event. Events carry an additional piece of data each time it is observed, such as HTTP response size. - Computers now accept a MetricsObserver, which tracks metrics for this particular computer. This allows us to decouple Computer classes and metrics information. The concrete MetricsObserver class we use within Minecraft exposes the ServerComputer directly, so we no longer need to do the awkward mapping and lookups! - The /computercraft command can now do aggregates (count, avg, max) over all Event metrics. This removes the need for special handling of computer and server time. There's also a small number of changes in removing the coupling between Computer and some of its dependencies (ILuaMachine, MainThreadExecutor). This makes some future refactorings easier, I promise!
2022-10-22 00:35:04 +00:00
for (var i = 0; i < fields.size(); i++) {
var metric = fields.get(i);
row[i + 1] = text(entry.getFormatted(metric.metric(), metric.aggregate()));
}
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
table.row(row);
Error when missing computers after executing the command This allows you to automate running various commands and still have them "work" if some computers are not loaded. Closes #47
2018-08-04 09:39:44 +00:00
}
Update CC: Tweaked to 1.13 Look, I originally had this split into several commits, but lots of other cleanups got mixed in. I then backported some of the cleanups to 1.12, did other tidy ups there, and eventually the web of merges was unreadable. Yes, this is a horrible mess, but it's still nicer than it was. Anyway, changes: - Flatten everything. For instance, there are now three instances of BlockComputer, two BlockTurtle, ItemPocketComputer. There's also no more BlockPeripheral (thank heavens) - there's separate block classes for each peripheral type. - Remove pretty much all legacy code. As we're breaking world compatibility anyway, we can remove all the code to load worlds from 1.4 days. - The command system is largely rewriten to take advantage of 1.13's new system. It's very fancy! - WidgetTerminal now uses Minecraft's "GUI listener" system. - BREAKING CHANGE: All the codes in keys.lua are different, due to the move to LWJGL 3. Hopefully this won't have too much of an impact. I don't want to map to the old key codes on the Java side, as there always ends up being small but slight inconsistencies. IMO it's better to make a clean break - people should be using keys rather than hard coding the constants anyway. - commands.list now allows fetching sub-commands. The ROM has already been updated to allow fancy usage such as commands.time.set("noon"). - Turtles, modems and cables can be waterlogged.
2019-04-02 12:27:27 +00:00
table.display(source);
return timings.size();
Error when missing computers after executing the command This allows you to automate running various commands and still have them "work" if some computers are not loaded. Closes #47
2018-08-04 09:39:44 +00:00
}
Rewrite computer selectors This adds support for computer selectors, in the style of entity selectors. The long-term goal here is to replace our existing ad-hoc selectors. However, to aid migration, we currently support both - the previous one will most likely be removed in MC 1.21. Computer selectors take the form @c[<key>=<value>,...]. Currently we support filtering by id, instance id, label, family (as before) and distance from the player (new!). The code also supports computers within a bounding box, but there's no parsing support for that yet. This commit also (finally) documents the /computercraft command. Well, sort of - it's definitely not my best word, but I couldn't find better words.
2024-03-12 20:12:13 +00:00
public static Set<ServerComputer> unwrap(CommandSourceStack source, Collection<ComputerSelector> suppliers) {
Set<ServerComputer> computers = new HashSet<>();
for (var supplier : suppliers) supplier.find(source).forEach(computers::add);
return computers;
}
Copy over CCTweaks's command system This adds several commands which may be useful for server owners. It'd be nice to integrate this into ComputerCraft itself, but the associated command framework is quite large so we'd have to think about it.
2017-12-06 15:51:02 +00:00
}