Interface | Description |
---|---|
Architecture |
This interface abstracts away any language specific details for the Machine.
|
Arguments |
This interface provides access to arguments passed to a
Callback . |
Context |
This is used to provide some context to
Callback s, i.e. |
Machine |
This interface allows interacting with a Machine obtained via the factory
method
Machine.create(MachineHost) . |
MachineHost |
This interface has to be implemented by 'hosts' of machine instances.
|
Signal |
A single signal that was queued on a machine.
|
Value |
A value object can be pushed to a machine like a primitive value.
|
Class | Description |
---|---|
ExecutionResult |
Used by the Machine to determine the result of a call to
Architecture.runThreaded(boolean) . |
ExecutionResult.Error |
Indicates that an error occurred and the computer should crash.
|
ExecutionResult.Shutdown |
Indicates tha the computer should shutdown or reboot.
|
ExecutionResult.Sleep |
Indicates the machine may sleep for the specified number of ticks.
|
ExecutionResult.SynchronizedCall |
Indicates that a synchronized call should be performed.
|
Exception | Description |
---|---|
LimitReachedException |
Used to signal that the direct call limit for the current server tick has
been reached in
Machine.invoke(String, String, Object[]) . |
Annotation Type | Description |
---|---|
Architecture.Name |
Architectures can be annotated with this to provide a nice display name.
|
Architecture.NoMemoryRequirements |
Architectures flagged with this annotation can potentially run without
any additional memory installed in the computer.
|
Callback |
This annotation can be used for methods in an
Environment to mark
them for exposure to computers. |
Machine
class, you can create new machine
instances, i.e. essentially computer "cores", that will run code. This allows
you to implement your own computer blocks. Or robots. Or whatever you come up
with.
The interfaces in here also allow you to implement an arbitrary new
Architecture
, which can then be used when
creating a new Machine
using the factory
methods in Machine
. An architecture could be a custom
language interpreter, or a full blown hardware emulator for old microchips.
There are also a couple of interfaces in here that are not meant to be
implemented, but merely to allow accessing some mod internals in a regulated
fashion, such as Robot
.