dan200.computercraft.api.peripheral.IComputerAccess Java Examples

public IMethodCall addPeripheralArgs(IMethodCall call, IComputerAccess access, ILuaContext context) {
	final CCArchitectureAccess wrapper = new CCArchitectureAccess(access, converter);
	return addCommonArgs(call, context)
			.setEnv(Constants.ARG_ARCHITECTURE, wrapper)
			.setEnv(Constants.ARG_ACCESS, wrapper)
			.setEnv(Constants.ARG_COMPUTER, access);
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) {
       try {
           return callMethod(method, arguments);
       } catch(Exception e) {
       	BRLog.info("Exception encountered when invoking computercraft method: %s", e.getMessage());
           e.printStackTrace();
       }
       return null;
   }
 

@Override
@Optional.Method(modid = "ComputerCraft")
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws LuaException {
       try {
           return callMethod(method, arguments);
       } catch(Exception e) {
       	// Rethrow errors as LuaExceptions for CC
       	throw new LuaException(e.getMessage());
       }
   }
 

public static void init() {
	final MethodSelector peripheralSelector = new MethodSelector(Constants.ARCH_COMPUTER_CRAFT)
			.allowReturnSignal()
			.addDefaultEnv()
			.addProvidedEnv(Constants.ARG_ACCESS, IArchitectureAccess.class)
			.addProvidedEnv(Constants.ARG_COMPUTER, IComputerAccess.class)
			.addProvidedEnv(Constants.ARG_CONTEXT, ILuaContext.class);

	PERIPHERAL_METHODS_FACTORY = new ComposedMethodsFactory<IndexedMethodMap>(AdapterRegistry.PERIPHERAL_ADAPTERS, peripheralSelector) {
		@Override
		protected IndexedMethodMap wrapMethods(Class<?> targetCls, Map<String, IMethodExecutor> methods) {
			return new IndexedMethodMap(methods);
		}
	};

	// can't push events, so not allowing return signals
	final MethodSelector objectSelector = new MethodSelector(Constants.ARCH_COMPUTER_CRAFT)
			.addDefaultEnv()
			.addProvidedEnv(Constants.ARG_CONTEXT, ILuaContext.class);

	OBJECT_METHODS_FACTORY = new ComposedMethodsFactory<IndexedMethodMap>(AdapterRegistry.OBJECT_ADAPTERS, objectSelector) {
		@Override
		protected IndexedMethodMap wrapMethods(Class<?> targetCls, Map<String, IMethodExecutor> methods) {
			return new IndexedMethodMap(methods);
		}
	};

	CommandDump.addArchSerializer("ComputerCraft", "peripheral", DocBuilder.TILE_ENTITY_DECORATOR, PERIPHERAL_METHODS_FACTORY);
	CommandDump.addArchSerializer("ComputerCraft", "object", DocBuilder.SCRIPT_OBJECT_DECORATOR, OBJECT_METHODS_FACTORY);

	final IConverter converter = new TypeConversionRegistryCC();
	// CC converter is default one (legacy behaviour)
	TypeConvertersProvider.INSTANCE.registerConverter(Constants.ARCH_COMPUTER_CRAFT, converter);

	TypeClassifier.INSTANCE.registerType(ILuaObject.class, SingleArgType.OBJECT);

	ENV = new ComputerCraftEnv(converter);
}
 

/**
 * Called on a event sensor
 * @param newRedstoneStrength
 */
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
private void notifyComputers(Object... arguments){
    for(IComputerAccess computer : attachedComputers) {
        computer.queueEvent(getType(), arguments);
    }
}
 

@Override
public void attach(IComputerAccess computer) {
	computer.mount(MOUNT_NAME, AdapterPeripheral.MOUNT);
	computer.mount("rom/help/" + computer.getAttachmentName(), docMount);
	if (target instanceof IAttachable) {
		IArchitectureAccess access = accessCache.getOrCreate(computer);
		((IAttachable)target).addComputer(access);
	}
	if (target instanceof IComputerCraftAttachable) ((IComputerCraftAttachable)target).addComputer(computer);
}
 

@Override
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws LuaException, InterruptedException{
    try {
        return luaMethods.get(method).call(arguments);
    } catch(Exception e) {
        throw new LuaException(e.getMessage());
    }
}
 

private void sendEvent(String name, Object... parms){
    if(Loader.isModLoaded(ModIds.COMPUTERCRAFT)) {
        for(IComputerAccess computer : attachedComputers) {
            computer.queueEvent(name, parms);
        }
    }
}
 

@Override
public void detach(IComputerAccess computer) {
	if (target instanceof IAttachable) {
		IArchitectureAccess access = accessCache.remove(computer);
		if (access != null) ((IAttachable)target).removeComputer(access);
	}

	if (target instanceof IComputerCraftAttachable) ((IComputerCraftAttachable)target).removeComputer(computer);
}
 

@Override
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws LuaException{
    try {
        return luaMethods.get(method).call(arguments);
    } catch(Exception e) {
        throw new LuaException(e.getMessage());
    }
}
 

@Override
public Object[] callMethod(final IComputerAccess computer, final ILuaContext context, final int index, final Object[] arguments) throws LuaException, InterruptedException {
	// this should throw if peripheral isn't attached
	computer.getAttachmentName();

	final IMethodExecutor method = methods.getMethod(index);
	Preconditions.checkNotNull(method, "Invalid method index: %d", index);

	final IMethodCall preparedCall = prepareCall(method, computer, context);

	final Optional<String> returnSignal = method.getReturnSignal();
	if (returnSignal.isPresent()) {
		final int callbackId = SignallingGlobals.instance.nextCallbackId();
		final String returnSignalId = returnSignal.get();
		if (method.isAsynchronous()) {
			SignallingGlobals.instance.scheduleTask(new Runnable() {
				@Override
				public void run() {
					computer.queueEvent(returnSignalId, executeToSignal(callbackId, index, preparedCall, arguments));
				}
			});
		} else {
			context.issueMainThreadTask(new ILuaTask() {
				@Override
				public Object[] execute() {
					computer.queueEvent(returnSignalId, executeToSignal(callbackId, index, preparedCall, arguments));
					// this will be used as 'task_complete' result, so we will ignore it
					return NULL;
				}
			});
		}
		return new Object[] { callbackId };
	} else {
		if (method.isAsynchronous()) return executeCall(preparedCall, index, arguments);
		else {
			Object[] results = SynchronousExecutor.executeInMainThread(context, new SynchronousExecutor.Task() {
				@Override
				public Object[] execute() throws LuaException, InterruptedException {
					return executeCall(preparedCall, index, arguments);
				}
			});
			return results;
		}
	}
}
 

private IMethodCall prepareCall(IMethodExecutor executor, IComputerAccess computer, ILuaContext context) {
	final IMethodCall call = executor.startCall(target);
	return ModuleComputerCraft.ENV.addPeripheralArgs(call, computer, context);
}
 

@Override
protected IArchitectureAccess create(IComputerAccess computer) {
	return ModuleComputerCraft.ENV.createAccess(computer);
}
 

public CCArchitectureAccess(IComputerAccess access, IConverter converter) {
	super(converter);
	this.access = access;
}
 

@Override
public void attach(IComputerAccess computer) {}
 

@Override
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) {
	return ArrayUtils.toArray("This peripheral is broken. You can show your log in #OpenMods");
}
 

public IArchitectureAccess createAccess(final IComputerAccess access) {
	return new CCArchitectureAccess(access, converter);
}
 

@Override
public void detach(IComputerAccess computer) {}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public void detach(IComputerAccess computer) {
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public void detach(IComputerAccess computer) {
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public void attach(IComputerAccess computer) {
}
 

@Override
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws LuaException,
InterruptedException {

    if (method == 0) {
        if (arguments.length == 0)
            throw new LuaException("At least 1 argument is required (face)");
        return new Object[] { te.setFace(toFD(arguments[0])) };
    } else if (method == 1) {
        return new Object[] { te.getFace().ordinal() };
    } else if (method == 2) {
        if (!(te.getMovement() instanceof MovementSlide))
            throw new LuaException("This is not a slider motor!");
        if (arguments.length == 0)
            throw new LuaException("At least 1 argument is required (direction)");
        ((IMovementSlide) te.getMovement()).setDirection(toFD(arguments[0]));
        return new Object[] {};
    } else if (method == 3) {
        if (!(te.getMovement() instanceof MovementSlide))
            throw new LuaException("This is not a slider motor!");
        return new Object[] { ((IMovementSlide) te.getMovement()).getDirection().ordinal() };
    } else if (method == 4) {
        throw new LuaException("Not implemented yet, sorry D:");
        // if (arguments.length < 2)
        // throw new LuaException("At least 2 arguments are required (face, direction)");
        //
        // ForgeDirection face = toFD(arguments[0]);
        // ForgeDirection direction = toFD(arguments[1]);
        //
        // if (face == null || direction == null)
        // throw new LuaException("Invalid directions!");
        // if (face == direction || face == direction.getOpposite())
        // throw new LuaException("Motors cannot push or pull blocks!");
        //
        // te.setFace(face, true);
        // te.setDirection(direction, true);
        //
        // return new Object[] { true };
    } else if (method == 5) {
        return new Object[] { te.move() };
    }

    return null;
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public void attach(IComputerAccess computer) {
}
 

@Override
public void detach(IComputerAccess computer) {
	if (peripheral != null) peripheral.detach(computer);
}
 

@Override
public void attach(IComputerAccess computer) {
	if (peripheral != null) peripheral.attach(computer);
}
 

@Override
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws LuaException, InterruptedException {
	return (peripheral != null)? peripheral.callMethod(computer, context, method, arguments) : null;
}
 

@Override
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
public void detach(IComputerAccess computer){
    attachedComputers.remove(computer);
}
 

@Override
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
public void attach(IComputerAccess computer){
    attachedComputers.add(computer);
}
 

@Override
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
public void detach(IComputerAccess computer){}
 

@Override
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
public void attach(IComputerAccess computer){}