generated from tilera/1710mod
351 lines
14 KiB
Java
351 lines
14 KiB
Java
/**
|
|
* This file is part of the public ComputerCraft API - http://www.computercraft.info
|
|
* Copyright Daniel Ratcliffe, 2011-2015. This API may be redistributed unmodified and in
|
|
* full only. For help using the API, and posting your mods, visit the forums at
|
|
* computercraft.info.
|
|
*/
|
|
|
|
package dan200.computercraft.api;
|
|
|
|
import java.lang.reflect.Method;
|
|
|
|
import dan200.computercraft.api.filesystem.IMount;
|
|
import dan200.computercraft.api.filesystem.IWritableMount;
|
|
import dan200.computercraft.api.media.IMediaProvider;
|
|
import dan200.computercraft.api.peripheral.IPeripheralProvider;
|
|
import dan200.computercraft.api.permissions.ITurtlePermissionProvider;
|
|
import dan200.computercraft.api.redstone.IBundledRedstoneProvider;
|
|
import dan200.computercraft.api.turtle.ITurtleUpgrade;
|
|
import net.minecraft.world.World;
|
|
|
|
/**
|
|
* The static entry point to the ComputerCraft API.
|
|
* Members in this class must be called after mod_ComputerCraft has been initialised,
|
|
* but may be called before it is fully loaded.
|
|
*/
|
|
public final class ComputerCraftAPI {
|
|
public static boolean isInstalled() {
|
|
findCC();
|
|
return computerCraft != null;
|
|
}
|
|
|
|
public static String getInstalledVersion() {
|
|
findCC();
|
|
|
|
if (computerCraft_getVersion != null) {
|
|
try {
|
|
return (String) computerCraft_getVersion.invoke(null);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public static String getAPIVersion() {
|
|
return "1.75";
|
|
}
|
|
|
|
/**
|
|
* Creates a numbered directory in a subfolder of the save directory for a given
|
|
* world, and returns that number.<br> Use in conjuction with createSaveDirMount() to
|
|
* create a unique place for your peripherals or media items to store files.<br>
|
|
* @param world The world for which the save dir should be created. This should be the
|
|
* serverside world object.
|
|
* @param parentSubPath The folder path within the save directory where the new
|
|
* directory should be created. eg: "computercraft/disk"
|
|
* @return The numerical value of the name of the new folder, or -1 if the folder
|
|
* could not be created for some reason.<br>
|
|
* eg: if createUniqueNumberedSaveDir( world, "computer/disk" ) was called returns 42,
|
|
* then "computer/disk/42" is now available for writing.
|
|
* @see #createSaveDirMount(World, String, long)
|
|
*/
|
|
public static int createUniqueNumberedSaveDir(World world, String parentSubPath) {
|
|
findCC();
|
|
|
|
if (computerCraft_createUniqueNumberedSaveDir != null) {
|
|
try {
|
|
return (Integer) computerCraft_createUniqueNumberedSaveDir.invoke(
|
|
null, world, parentSubPath
|
|
);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Creates a file system mount that maps to a subfolder of the save directory for a
|
|
* given world, and returns it.<br> Use in conjuction with IComputerAccess.mount() or
|
|
* IComputerAccess.mountWritable() to mount a folder from the users save directory
|
|
* onto a computers file system.<br>
|
|
* @param world The world for which the save dir can be found. This should be the
|
|
* serverside world object.
|
|
* @param subPath The folder path within the save directory that the mount should map
|
|
* to. eg: "computer/disk/42".<br>
|
|
* Use createUniqueNumberedSaveDir() to create a new numbered folder to use.
|
|
* @param capacity The ammount of data that can be stored in the directory before it
|
|
* fills up, in bytes.
|
|
* @return The mount, or null if it could be created for some reason. Use
|
|
* IComputerAccess.mount() or IComputerAccess.mountWritable()
|
|
* to mount this on a Computers' file system.
|
|
* @see #createUniqueNumberedSaveDir(World, String)
|
|
* @see dan200.computercraft.api.peripheral.IComputerAccess#mount(String,
|
|
* dan200.computercraft.api.filesystem.IMount)
|
|
* @see dan200.computercraft.api.peripheral.IComputerAccess#mountWritable(String,
|
|
* dan200.computercraft.api.filesystem.IWritableMount)
|
|
* @see dan200.computercraft.api.filesystem.IMount
|
|
* @see IWritableMount
|
|
*/
|
|
public static IWritableMount
|
|
createSaveDirMount(World world, String subPath, long capacity) {
|
|
findCC();
|
|
|
|
if (computerCraft_createSaveDirMount != null) {
|
|
try {
|
|
return (IWritableMount
|
|
) computerCraft_createSaveDirMount.invoke(null, world, subPath, capacity);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Creates a file system mount to a resource folder, and returns it.<br>
|
|
* Use in conjuction with IComputerAccess.mount() or IComputerAccess.mountWritable()
|
|
* to mount a resource folder onto a computers file system.<br> The files in this
|
|
* mount will be a combination of files in the specified mod jar, and resource packs
|
|
* that contain resources with the same domain and path.<br>
|
|
* @param modClass A class in whose jar to look first for the resources to mount.
|
|
* Using your main mod class is recommended. eg: MyMod.class
|
|
* @param domain The domain under which to look for resources. eg: "mymod"
|
|
* @param subPath The domain under which to look for resources. eg:
|
|
* "mymod/lua/myfiles"
|
|
* @return The mount, or null if it could be created for some reason. Use
|
|
* IComputerAccess.mount() or IComputerAccess.mountWritable()
|
|
* to mount this on a Computers' file system.
|
|
* @see dan200.computercraft.api.peripheral.IComputerAccess#mount(String,
|
|
* dan200.computercraft.api.filesystem.IMount)
|
|
* @see dan200.computercraft.api.peripheral.IComputerAccess#mountWritable(String,
|
|
* IWritableMount)
|
|
* @see dan200.computercraft.api.filesystem.IMount
|
|
*/
|
|
public static IMount
|
|
createResourceMount(Class modClass, String domain, String subPath) {
|
|
findCC();
|
|
|
|
if (computerCraft_createResourceMount != null) {
|
|
try {
|
|
return (IMount) computerCraft_createResourceMount.invoke(
|
|
null, modClass, domain, subPath
|
|
);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Registers a peripheral handler to convert blocks into IPeripheral implementations.
|
|
* @see dan200.computercraft.api.peripheral.IPeripheral
|
|
* @see dan200.computercraft.api.peripheral.IPeripheralProvider
|
|
*/
|
|
public static void registerPeripheralProvider(IPeripheralProvider handler) {
|
|
findCC();
|
|
|
|
if (computerCraft_registerPeripheralProvider != null) {
|
|
try {
|
|
computerCraft_registerPeripheralProvider.invoke(null, handler);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers a new turtle turtle for use in ComputerCraft. After calling this,
|
|
* users should be able to craft Turtles with your new turtle. It is recommended to
|
|
* call this during the load() method of your mod.
|
|
* @see dan200.computercraft.api.turtle.ITurtleUpgrade
|
|
*/
|
|
public static void registerTurtleUpgrade(ITurtleUpgrade upgrade) {
|
|
if (upgrade != null) {
|
|
findCC();
|
|
|
|
if (computerCraft_registerTurtleUpgrade != null) {
|
|
try {
|
|
computerCraft_registerTurtleUpgrade.invoke(null, upgrade);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers a bundled redstone handler to provide bundled redstone output for blocks
|
|
* @see dan200.computercraft.api.redstone.IBundledRedstoneProvider
|
|
*/
|
|
public static void registerBundledRedstoneProvider(IBundledRedstoneProvider handler) {
|
|
findCC();
|
|
|
|
if (computerCraft_registerBundledRedstoneProvider != null) {
|
|
try {
|
|
computerCraft_registerBundledRedstoneProvider.invoke(null, handler);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If there is a Computer or Turtle at a certain position in the world, get it's
|
|
* bundled redstone output.
|
|
* @see dan200.computercraft.api.redstone.IBundledRedstoneProvider
|
|
* @return If there is a block capable of emitting bundled redstone at the location,
|
|
* it's signal (0-65535) will be returned.
|
|
* If there is no block capable of emitting bundled redstone at the location, -1 will
|
|
* be returned.
|
|
*/
|
|
public static int
|
|
getBundledRedstoneOutput(World world, int x, int y, int z, int side) {
|
|
findCC();
|
|
|
|
if (computerCraft_getDefaultBundledRedstoneOutput != null) {
|
|
try {
|
|
return (Integer) computerCraft_getDefaultBundledRedstoneOutput.invoke(
|
|
null, world, x, y, z, side
|
|
);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Registers a media handler to provide IMedia implementations for Items
|
|
* @see dan200.computercraft.api.media.IMediaProvider
|
|
*/
|
|
public static void registerMediaProvider(IMediaProvider handler) {
|
|
findCC();
|
|
|
|
if (computerCraft_registerMediaProvider != null) {
|
|
try {
|
|
computerCraft_registerMediaProvider.invoke(null, handler);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers a permission handler to restrict where turtles can move or build
|
|
* @see dan200.computercraft.api.permissions.ITurtlePermissionProvider
|
|
*/
|
|
public static void registerPermissionProvider(ITurtlePermissionProvider handler) {
|
|
findCC();
|
|
|
|
if (computerCraft_registerPermissionProvider != null) {
|
|
try {
|
|
computerCraft_registerPermissionProvider.invoke(null, handler);
|
|
} catch (Exception e) {
|
|
// It failed
|
|
}
|
|
}
|
|
}
|
|
|
|
// The functions below here are private, and are used to interface with the non-API
|
|
// ComputerCraft classes. Reflection is used here so you can develop your mod without
|
|
// decompiling ComputerCraft and including it in your solution, and so your mod won't
|
|
// crash if ComputerCraft is installed.
|
|
|
|
private static void findCC() {
|
|
if (!ccSearched) {
|
|
try {
|
|
computerCraft = Class.forName("dan200.computercraft.ComputerCraft");
|
|
computerCraft_getVersion = findCCMethod("getVersion", new Class[] {});
|
|
computerCraft_createUniqueNumberedSaveDir = findCCMethod(
|
|
"createUniqueNumberedSaveDir",
|
|
new Class[] { World.class, String.class }
|
|
);
|
|
computerCraft_createSaveDirMount = findCCMethod(
|
|
"createSaveDirMount",
|
|
new Class[] { World.class, String.class, Long.TYPE }
|
|
);
|
|
computerCraft_createResourceMount = findCCMethod(
|
|
"createResourceMount",
|
|
new Class[] { Class.class, String.class, String.class }
|
|
);
|
|
computerCraft_registerPeripheralProvider = findCCMethod(
|
|
"registerPeripheralProvider",
|
|
new Class[] { IPeripheralProvider.class }
|
|
);
|
|
computerCraft_registerTurtleUpgrade = findCCMethod(
|
|
"registerTurtleUpgrade", new Class[] { ITurtleUpgrade.class }
|
|
);
|
|
computerCraft_registerBundledRedstoneProvider = findCCMethod(
|
|
"registerBundledRedstoneProvider",
|
|
new Class[] { IBundledRedstoneProvider.class }
|
|
);
|
|
computerCraft_getDefaultBundledRedstoneOutput = findCCMethod(
|
|
"getDefaultBundledRedstoneOutput",
|
|
new Class[] { World.class,
|
|
Integer.TYPE,
|
|
Integer.TYPE,
|
|
Integer.TYPE,
|
|
Integer.TYPE }
|
|
);
|
|
computerCraft_registerMediaProvider = findCCMethod(
|
|
"registerMediaProvider", new Class[] { IMediaProvider.class }
|
|
);
|
|
computerCraft_registerPermissionProvider = findCCMethod(
|
|
"registerPermissionProvider",
|
|
new Class[] { ITurtlePermissionProvider.class }
|
|
);
|
|
} catch (Exception e) {
|
|
System.out.println("ComputerCraftAPI: ComputerCraft not found.");
|
|
} finally {
|
|
ccSearched = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Method findCCMethod(String name, Class[] args) {
|
|
try {
|
|
if (computerCraft != null) {
|
|
return computerCraft.getMethod(name, args);
|
|
}
|
|
|
|
return null;
|
|
} catch (NoSuchMethodException e) {
|
|
System.out.println(
|
|
"ComputerCraftAPI: ComputerCraft method " + name + " not found."
|
|
);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static boolean ccSearched = false;
|
|
private static Class computerCraft = null;
|
|
private static Method computerCraft_getVersion = null;
|
|
private static Method computerCraft_createUniqueNumberedSaveDir = null;
|
|
private static Method computerCraft_createSaveDirMount = null;
|
|
private static Method computerCraft_createResourceMount = null;
|
|
private static Method computerCraft_registerPeripheralProvider = null;
|
|
private static Method computerCraft_registerTurtleUpgrade = null;
|
|
private static Method computerCraft_registerBundledRedstoneProvider = null;
|
|
private static Method computerCraft_getDefaultBundledRedstoneOutput = null;
|
|
private static Method computerCraft_registerMediaProvider = null;
|
|
private static Method computerCraft_registerPermissionProvider = null;
|
|
}
|