1661 lines
72 KiB
Plaintext
1661 lines
72 KiB
Plaintext
# OpenComputers configuration. This file uses typesafe config's HOCON syntax.
|
|
# Try setting your syntax highlighting to Ruby, to help readability. At least
|
|
# in Sublime Text that works really well. Note that this file is overwritten
|
|
# whenever you start the game! Changes to the comments may vanish.
|
|
# Note that all mentions of 'KB' or 'kilobyte' mean 1024 bytes.
|
|
opencomputers {
|
|
|
|
# Chunkloader Upgrade settings.
|
|
chunkloader {
|
|
|
|
# This is a list of blacklisted dimensions. Chunkloaders may only be activated
|
|
# in dimensions that aren't present in this list.
|
|
dimBlacklist=[]
|
|
|
|
# This is a list of whitelisted dimensions. Chunkloaders may only be activated
|
|
# in dimensions that are present in this list. If this list is empty,
|
|
# chunkloaders may be activated to all dimensions not blacklisted. Note that the
|
|
# blacklist is always applied, so if an entry is present in both the
|
|
# whitelist and the blacklist, the blacklist will win.
|
|
dimWhitelist=[]
|
|
}
|
|
|
|
# Client side settings, presentation and performance related stuff.
|
|
client {
|
|
|
|
# The radius in which computer beeps can be heard.
|
|
beepRadius=16
|
|
|
|
# The sample rate used for generating beeps of computers' internal
|
|
# speakers. Use custom values at your own responsibility here; if it
|
|
# breaks OC you'll get no support. Some potentially reasonable
|
|
# lower values are 16000 or even 8000 (which was the old default, but
|
|
# leads to artifacting on certain frequencies).
|
|
beepSampleRate=44100
|
|
|
|
# The base volume of beeps generated by computers. This may be in a
|
|
# range of [0, 127], where 0 means mute (the sound will not even be
|
|
# generated), and 127 means maximum amplitude / volume.
|
|
beepVolume=32
|
|
|
|
# Whether to emit particle effects around players via nanomachines. This
|
|
# includes the basic particles giving a rough indication of the current
|
|
# power level of the nanomachines as well as particles emitted by the
|
|
# particle effect behaviors.
|
|
enableNanomachinePfx=true
|
|
|
|
# This is the scaling of the individual chars rendered on screens. This
|
|
# is set to slightly overscale per default, to avoid gaps between fully
|
|
# filled chars to appear (i.e. the block symbol that is used for cursor
|
|
# blinking for example) on less accurate hardware.
|
|
fontCharScale=1.01
|
|
|
|
# Which font renderer to use. Defaults to `hexfont` if invalid.
|
|
# Possible values:
|
|
# - hexfont: the (since 1.3.2) default font renderer. Font in .hex format
|
|
# capable of rendering many unicode glyphs.
|
|
# The used font data can be swapped out using resource packs,
|
|
# but is harder to work with, since it involves binary data.
|
|
# - texture: the old, font-texture based font renderer that was used
|
|
# in OC versions prior to 1.3.2. This will allow overriding
|
|
# the font texture as before. Keep in mind that this renderer
|
|
# is slightly less efficient than the new one, and more
|
|
# importantly, can only render code page 437 (as opposed to...
|
|
# a *lot* of unicode).
|
|
fontRenderer=hexfont
|
|
|
|
# The distance at which to start fading out the hologram (as with
|
|
# hologramRenderDistance). This is purely cosmetic, to avoid image
|
|
# disappearing instantly when moving too far away from a projector.
|
|
# It does not affect performance. Holograms are transparent anyway.
|
|
hologramFadeStartDistance=48
|
|
|
|
# This controls how often holograms 'flicker'. This is the chance that it
|
|
# flickers for *each frame*, meaning if you're running at high FPS you
|
|
# may want to lower this a bit, to avoid it flickering too much.
|
|
hologramFlickerFrequency=0.025
|
|
|
|
# The maximum render distance of a hologram projected by a highest tier
|
|
# hologram projector when at maximum scale. Render distance is scaled
|
|
# down with the actual scale of the hologram.
|
|
hologramRenderDistance=64
|
|
|
|
# The maximum distance at which to render text on screens. Rendering text
|
|
# can be pretty expensive, so if you have a lot of screens you'll want to
|
|
# avoid huge numbers here. Note that this setting is client-sided, and
|
|
# only has an impact on render performance on clients.
|
|
maxScreenTextRenderDistance=20
|
|
|
|
# The color of monochrome text (i.e. displayed when in 1-bit color depth,
|
|
# e.g. tier one screens / GPUs, or higher tier set to 1-bit color depth).
|
|
# Defaults to white, feel free to make it some other color, tho!
|
|
monochromeColor="0xFFFFFF"
|
|
|
|
# Position of the power indicator for nanomachines, by default left to the
|
|
# player's health, specified by negative values. Values in [0, 1) will be
|
|
# treated as relative positions, values in [1, inf) will be treated as
|
|
# absolute positions.
|
|
nanomachineHudPos=[
|
|
-1,
|
|
-1
|
|
]
|
|
|
|
# Render robots' names as a label above them when near them
|
|
robotLabels=true
|
|
|
|
# The distance at which to start fading out the text on screens. This is
|
|
# purely cosmetic, to avoid text disappearing instantly when moving too
|
|
# far away from a screen. This should have no measurable impact on
|
|
# performance. Note that this needs OpenGL 1.4 to work, otherwise text
|
|
# will always just instantly disappear when moving away from the screen
|
|
# displaying it.
|
|
screenTextFadeStartDistance=15
|
|
|
|
# The volume multiplier applied to sounds from this mod like the computer
|
|
# running noise. Disable sounds by setting this to zero.
|
|
soundVolume=1
|
|
|
|
# If you prefer the text on the screens to be aliased (you know, *not*
|
|
# anti-aliased / smoothed) turn this option off.
|
|
textAntiAlias=true
|
|
|
|
# Whether to apply linear filtering for text displayed on screens when the
|
|
# screen has to be scaled down - i.e. the text is rendered at a resolution
|
|
# lower than their native one, e.g. when the GUI scale is less than one or
|
|
# when looking at a far away screen. This leads to smoother text for
|
|
# scaled down text but results in characters not perfectly connecting
|
|
# anymore (for example for box drawing characters. Look it up on
|
|
# Wikipedia.)
|
|
textLinearFiltering=false
|
|
}
|
|
|
|
# Computer related settings, concerns server performance and security.
|
|
computer {
|
|
|
|
# The provided call budgets by the three tiers of CPU and memory. Higher
|
|
# budgets mean that more direct calls can be performed per tick. You can
|
|
# raise this to increase the "speed" of computers at the cost of higher
|
|
# real CPU time. Lower this to lower the load Lua executors put on your
|
|
# machine / server, at the cost of slower computers. This list must
|
|
# contain exactly three entries, or it will be ignored.
|
|
callBudgets=[
|
|
0.5,
|
|
1,
|
|
1.5
|
|
]
|
|
|
|
# This determines whether computers can only be used by players that are
|
|
# registered as users on them. Per default a newly placed computer has no
|
|
# users. Whenever there are no users the computer is free for all. Users
|
|
# can be managed via the Lua API (computer.addUser, computer.removeUser,
|
|
# computer.users). If this is true, the following interactions are only
|
|
# possible for users:
|
|
# - input via the keyboard and touch screen.
|
|
# - inventory management.
|
|
# - breaking the computer block.
|
|
# If this is set to false, all computers will always be usable by all
|
|
# players, no matter the contents of the user list. Note that operators
|
|
# are treated as if they were in the user list of every computer, i.e. no
|
|
# restrictions apply to them.
|
|
# See also: `maxUsers` and `maxUsernameLength`.
|
|
canComputersBeOwned=true
|
|
|
|
# The number of components the different CPU tiers support. This list
|
|
# must contain exactly four entries, or it will be ignored.
|
|
cpuComponentCount=[
|
|
8,
|
|
12,
|
|
16,
|
|
1024
|
|
]
|
|
|
|
# The maximum size of the byte array that can be stored on EEPROMs as configuration data.
|
|
eepromDataSize=256
|
|
|
|
# The maximum size of the byte array that can be stored on EEPROMs as executable data..
|
|
eepromSize=4096
|
|
|
|
# Whether to delete all contents in the /tmp file system when performing
|
|
# a 'soft' reboot (i.e. via `computer.shutdown(true)`). The tmpfs will
|
|
# always be erased when the computer is completely powered off, even if
|
|
# it crashed. This setting is purely for software-triggered reboots.
|
|
eraseTmpOnReboot=false
|
|
|
|
# The time in milliseconds that scheduled computers are forced to wait
|
|
# before executing more code. This avoids computers to "busy idle",
|
|
# leading to artificially high CPU load. If you're worried about
|
|
# performance on your server, increase this number a little (it should
|
|
# never exceed 50, a single tick, though) to reduce CPU load even more.
|
|
executionDelay=12
|
|
|
|
# Settings specific to the Lua architecture.
|
|
lua {
|
|
|
|
# Whether to allow loading precompiled bytecode via Lua's `load`
|
|
# function, or related functions (`loadfile`, `dofile`). Enable this
|
|
# only if you absolutely trust all users on your server and all Lua
|
|
# code you run. This can be a MASSIVE SECURITY RISK, since precompiled
|
|
# code can easily be used for exploits, running arbitrary code on the
|
|
# real server! I cannot stress this enough: only enable this is you
|
|
# know what you're doing.
|
|
allowBytecode=false
|
|
|
|
# Whether to allow user defined __gc callbacks, i.e. __gc callbacks
|
|
# defined *inside* the sandbox. Since garbage collection callbacks
|
|
# are not sandboxed (hooks are disabled while they run), this is not
|
|
# recommended.
|
|
allowGC=false
|
|
|
|
# Whether to make the Lua 5.3 architecture the default architecture.
|
|
# If enabled, a crafted CPU will first be the Lua 5.3 architecture.
|
|
defaultLua53=true
|
|
|
|
# Whether to make the Lua 5.3 architecture available. If enabled, you
|
|
# can reconfigure any CPU to use the Lua 5.3 architecture.
|
|
enableLua53=true
|
|
|
|
# The total maximum amount of memory a Lua machine may use for user
|
|
# programs. The total amount made available by components cannot
|
|
# exceed this. The default is 64*1024*1024. Keep in mind that this does
|
|
# not include memory reserved for built-in code such as `machine.lua`.
|
|
# IMPORTANT: DO NOT MESS WITH THIS UNLESS YOU KNOW WHAT YOU'RE DOING.
|
|
# IN PARTICULAR, DO NOT REPORT ISSUES AFTER MESSING WITH THIS!
|
|
maxTotalRam=67108864
|
|
|
|
# This setting allows you to fine-tune how RAM sizes are scaled internally
|
|
# on 64 Bit machines (i.e. when the Minecraft server runs in a 64 Bit VM).
|
|
# Why is this even necessary? Because objects consume more memory in a 64
|
|
# Bit environment than in a 32 Bit one, due to pointers and possibly some
|
|
# integer types being twice as large. It's actually impossible to break
|
|
# this down to a single number, so this is really just a rough guess. If
|
|
# you notice this doesn't match what some Lua program would use on 32 bit,
|
|
# feel free to play with this and report your findings!
|
|
# Note that the values *displayed* to Lua via `computer.totalMemory` and
|
|
# `computer.freeMemory` will be scaled by the inverse, so that they always
|
|
# correspond to the "apparent" sizes of the installed memory modules. For
|
|
# example, when running a computer with a 64KB RAM module, even if it's
|
|
# scaled up to 96KB, `computer.totalMemory` will return 64KB, and if there
|
|
# are really 45KB free, `computer.freeMemory` will return 32KB.
|
|
ramScaleFor64Bit=1.8
|
|
|
|
# The sizes of the six levels of RAM, in kilobytes. This list must
|
|
# contain exactly six entries, or it will be ignored. Note that while
|
|
# there are six levels of RAM, they still fall into the three tiers of
|
|
# items (level 1, 2 = tier 1, level 3, 4 = tier 2, level 5, 6 = tier 3).
|
|
ramSizes=[
|
|
192,
|
|
256,
|
|
384,
|
|
512,
|
|
768,
|
|
1024
|
|
]
|
|
}
|
|
|
|
# The maximum depth a machine will queue signals before dropping them
|
|
# A machine state should be pulling signals via computer.pullSignal
|
|
# As the machine receives signals they are queued for pulling, and
|
|
# this maximum defines the max queue size. All signals recieved when
|
|
# the queue is full are discarded. Note that clipboard text creates
|
|
# a signal for each line of text. Thus client are limited to pasting
|
|
# text of this many lines. The default (and minimum) is 256
|
|
maxSignalQueueSize=256
|
|
|
|
# Sanity check for username length for users registered with computers. We
|
|
# store the actual user names instead of a hash to allow iterating the
|
|
# list of registered users on the Lua side.
|
|
# See also: `canComputersBeOwned`.
|
|
maxUsernameLength=32
|
|
|
|
# The maximum number of users that can be registered with a single
|
|
# computer. This is used to avoid computers allocating unchecked amounts
|
|
# of memory by registering an unlimited number of users. See also:
|
|
# `canComputersBeOwned`.
|
|
maxUsers=16
|
|
|
|
# The time in seconds to wait after a computer has been restored before it
|
|
# continues to run. This is meant to allow the world around the computer
|
|
# to settle, avoiding issues such as components in neighboring chunks
|
|
# being removed and then re-connected and other odd things that might
|
|
# happen.
|
|
startupDelay=0.25
|
|
|
|
# The overall number of threads to use to drive computers. Whenever a
|
|
# computer should run, for example because a signal should be processed or
|
|
# some sleep timer expired it is queued for execution by a worker thread.
|
|
# The higher the number of worker threads, the less likely it will be that
|
|
# computers block each other from running, but the higher the host
|
|
# system's load may become.
|
|
threads=4
|
|
|
|
# The time in seconds a program may run without yielding before it is
|
|
# forcibly aborted. This is used to avoid stupidly written or malicious
|
|
# programs blocking other computers by locking down the executor threads.
|
|
# Note that changing this won't have any effect on computers that are
|
|
# already running - they'll have to be rebooted for this to take effect.
|
|
timeout=5
|
|
}
|
|
|
|
# Settings that are intended for debugging issues, not for normal use.
|
|
# You usually don't want to touch these unless asked to do so by a developer.
|
|
debug {
|
|
|
|
# On some platforms the native library can crash the game, so there are
|
|
# a few checks in place to avoid trying to load it in those cases. This
|
|
# is Windows XP and Windows Server 2003, right. If you think it might
|
|
# work nonetheless (newer builds of Server2k3 e.g.) you might want to
|
|
# try setting this to `true`. Use this at your own risk. If the game
|
|
# crashes as a result of setting this to `true` DO NOT REPORT IT.
|
|
alwaysTryNative=false
|
|
|
|
# Enable debug card functionality. This may also be of use for custom
|
|
# maps, so it is enabled by default. If you run a server where people
|
|
# may cheat in items but should not have op/admin-like rights, you may
|
|
# want to set this to false or `deny`. Set this to `whitelist` if you
|
|
# want to enable whitelisting of debug card users (managed by command
|
|
# /oc_debugWhitelist). This will *not* remove the card, it will just
|
|
# make all functions it provides error out.
|
|
debugCardAccess=allow
|
|
|
|
# Prevent OC calling Lua's os.setlocale method to ensure number
|
|
# formatting is the same on all systems it is run on. Use this if you
|
|
# suspect this might mess with some other part of Java (this affects
|
|
# the native C locale).
|
|
disableLocaleChanging=false
|
|
|
|
# Disable memory limit enforcement. This means Lua states can
|
|
# theoretically use as much memory as they want. Only relevant when
|
|
# using the native library.
|
|
disableMemoryLimit=false
|
|
|
|
# Disable computer state persistence. This means that computers will
|
|
# automatically be rebooted when loaded after being unloaded, instead
|
|
# of resuming with their exection (it also means the state is not even
|
|
# saved). Only relevant when using the native library.
|
|
disablePersistence=false
|
|
|
|
# Disable user data support. This means any otherwise supported
|
|
# userdata (implementing the Value interface) will not be pushed
|
|
# to the Lua state.
|
|
disableUserdata=false
|
|
|
|
# Force the buffered file system to be case insensitive. This makes it
|
|
# impossible to have multiple files whose names only differ in their
|
|
# capitalization, which is commonly the case on Windows, for example.
|
|
# This only takes effect when bufferChanges is set to true.
|
|
forceCaseInsensitiveFS=false
|
|
|
|
# Forces the use of the LuaJ fallback instead of the native libraries.
|
|
# Use this if you have concerns using native libraries or experience
|
|
# issues with the native library.
|
|
forceLuaJ=false
|
|
|
|
# Force loading one specific library, to avoid trying to load any
|
|
# others. Use this if you get warnings in the log or are told to do
|
|
# so for debugging purposes ;-)
|
|
forceNativeLibWithName=""
|
|
|
|
# Pass along IDs of items and fluids when converting them to a table
|
|
# representation for Lua.
|
|
insertIdsInConverters=false
|
|
|
|
# This setting is meant for debugging errors that occur in Lua callbacks.
|
|
# Per default, if an error occurs and it has a message set, only the
|
|
# message is pushed back to Lua, and that's it. If you encounter weird
|
|
# errors or are developing an addon you'll want the stacktrace for those
|
|
# errors. Enabling this setting will log them to the game log. This is
|
|
# disabled per default to avoid spamming the log with inconsequentual
|
|
# exceptions such as IllegalArgumentExceptions and the like.
|
|
logCallbackErrors=false
|
|
|
|
# Logs the full error when a native library fails to load. This is
|
|
# disabled by default to avoid spamming the log, since libraries are
|
|
# iterated until one works, so it's very likely for some to fail. Use
|
|
# this in case all libraries fail to load even though you'd expect one
|
|
# to work.
|
|
logFullNativeLibLoadErrors=false
|
|
|
|
# Logs information about malformed glyphs (i.e. glyphs that deviate in
|
|
# width from what wcwidth says).
|
|
logHexFontErrors=false
|
|
|
|
# Used to suppress log spam for OpenGL errors on derpy drivers. I'm
|
|
# quite certain the code in the font render is valid, display list
|
|
# compatible OpenGL, but it seems to cause 'invalid operation' errors
|
|
# when executed as a display list. I'd be happy to be proven wrong,
|
|
# since it'd restore some of my trust into AMD drivers...
|
|
logOpenGLErrors=false
|
|
|
|
# Extract the native library with Lua into the system's temporary
|
|
# directory instead of the game directory (e.g. /tmp on Linux). The
|
|
# default is to extract into the game directory, to avoid issues when
|
|
# the temporary directory is mounted as noexec (meaning the lib cannot
|
|
# be loaded). There is also less of a chance of conflicts when running
|
|
# multiple servers or server and client on the same machine.
|
|
nativeInTmpDir=false
|
|
|
|
# Due to a bug in Minecraft's lighting code there's an issue where
|
|
# lighting does not properly update near light emitting blocks that are
|
|
# fully solid - like screens, for example. This can be annoying when
|
|
# using other blocks that dynamically change their brightness (e.g. for
|
|
# the addon mod OpenLights). Enable this to force light emitting blocks
|
|
# in oc to periodically (every two seconds) do an update. This should
|
|
# not have an overly noticeable impact on performance, but it's disabled
|
|
# by default because it is unnecessary in *most* cases.
|
|
periodicallyForceLightUpdate=false
|
|
|
|
# Whether to always register the LuaJ architecture - even if the native
|
|
# library is available. In that case it is possible to switch between
|
|
# the two like any other registered architecture.
|
|
registerLuaJArchitecture=false
|
|
|
|
# This is meant for debugging errors. Enabling this has a high impact
|
|
# on computers' save and load performance, so you should not enable
|
|
# this unless you're asked to.
|
|
verbosePersistenceErrors=false
|
|
}
|
|
|
|
# File system related settings, performance and and balancing.
|
|
filesystem {
|
|
|
|
# Whether persistent file systems such as disk drives should be
|
|
# 'buffered', and only written to disk when the world is saved. This
|
|
# applies to all hard drives. The advantage of having this enabled is that
|
|
# data will never go 'out of sync' with the computer's state if the game
|
|
# crashes. The price is slightly higher memory consumption, since all
|
|
# loaded files have to be kept in memory (loaded as in when the hard drive
|
|
# is in a computer).
|
|
bufferChanges=true
|
|
|
|
# The base 'cost' of a single file or directory on a limited file system,
|
|
# such as hard drives. When computing the used space we add this cost to
|
|
# the real size of each file (and folders, which are zero sized
|
|
# otherwise). This is to ensure that users cannot spam the file system
|
|
# with an infinite number of files and/or folders. Note that the size
|
|
# returned via the API will always be the real file size, however.
|
|
fileCost=512
|
|
|
|
# The size of writable floppy disks, in kilobytes.
|
|
floppySize=512
|
|
|
|
# Number of physical platters to pretend a disk has in unmanaged mode. This
|
|
# controls seek times, in how it emulates sectors overlapping (thus sharing
|
|
# a common head position for access).
|
|
hddPlatterCounts=[
|
|
2,
|
|
4,
|
|
8
|
|
]
|
|
|
|
# The sizes of the three tiers of hard drives, in kilobytes. This list
|
|
# must contain exactly three entries, or it will be ignored.
|
|
hddSizes=[
|
|
1024,
|
|
2048,
|
|
4096
|
|
]
|
|
|
|
# The maximum number of file handles any single computer may have open at
|
|
# a time. Note that this is *per filesystem*. Also note that this is only
|
|
# enforced by the filesystem node - if an add-on decides to be fancy it
|
|
# may well ignore this. Since file systems are usually 'virtual' this will
|
|
# usually not have any real impact on performance and won't be noticeable
|
|
# on the host operating system.
|
|
maxHandles=16
|
|
|
|
# The maximum block size that can be read in one 'read' call on a file
|
|
# system. This is used to limit the amount of memory a call from a user
|
|
# program can cause to be allocated on the host side: when 'read' is,
|
|
# called a byte array with the specified size has to be allocated. So if
|
|
# this weren't limited, a Lua program could trigger massive memory
|
|
# allocations regardless of the amount of RAM installed in the computer it
|
|
# runs on. As a side effect this pretty much determines the read
|
|
# performance of file systems.
|
|
maxReadBuffer=2048
|
|
|
|
# When skipping more than this number of sectors in unmanaged mode, the
|
|
# pause specified in sectorSeekTime will be enforced. We use this instead
|
|
# of linear scaling for movement because those values would have to be
|
|
# really small, which is hard to conceptualize and configure.
|
|
sectorSeekThreshold=128
|
|
|
|
# The time to pause when the head movement threshold is exceeded.
|
|
sectorSeekTime=0.1
|
|
|
|
# The size of the /tmp filesystem that each computer gets for free. If
|
|
# set to a non-positive value the tmp file system will not be created.
|
|
tmpSize=64
|
|
}
|
|
|
|
# Graphics Card Component Settings
|
|
gpu {
|
|
|
|
# This setting assigns the budget call cost to invoke bitblt to write vram
|
|
# to a screen. Video ram can bitblit to a screen which can cause real life
|
|
# network laod the defaults settings put bitblit network impact close to gpu.set
|
|
# Increase these values to throttle bitblt more. The cost tier N is bitbltCost * 2^(tier)
|
|
# default is .5, which gives: .5, 1, 4
|
|
bitbltCost=0.5
|
|
|
|
# Video ram can be allocated on a gpu. The amount of vram you can allocate
|
|
# is equal to the width*height of the max resolution of the gpu multiplied
|
|
# by the "vramSize" for that tier. For example, a T2 gpu can have 80*25*2 of
|
|
# text buffer space allocated
|
|
vramSizes=[
|
|
1,
|
|
2,
|
|
3
|
|
]
|
|
}
|
|
hologram {
|
|
|
|
# Whether the hologram block should provide light. It'll also emit light
|
|
# when off, because having state-based light in MC is... painful.
|
|
emitLight=true
|
|
|
|
# This controls the maximum scales of holograms, by tier.
|
|
# The size at scale 1 is 3x2x3 blocks, at scale 3 the hologram will
|
|
# span up to 9x6x9 blocks. Unlike most other `client' settings, this
|
|
# value is only used for validation *on the server*, with the effects
|
|
# only being visible on the client.
|
|
# Warning: very large values may lead to rendering and/or performance
|
|
# issues due to the high view distance! Increase at your own peril.
|
|
maxScale=[
|
|
3,
|
|
4
|
|
]
|
|
|
|
# This controls the maximum translation of holograms, by tier.
|
|
# The scale is in "hologram sizes", i.e. scale 1 allows offsetting a
|
|
# hologram once by its own size.
|
|
maxTranslation=[
|
|
0.25,
|
|
0.5
|
|
]
|
|
|
|
# The delay forced on computers between calls to `hologram.setRaw`, in
|
|
# seconds. Lower this if you want faster updates, raise this if you're
|
|
# worried about bandwidth use; in *normal* use-cases this will never be
|
|
# an issue. When abused, `setRaw` can be used to generate network traffic
|
|
# due to changed data being sent to clients. With the default settings,
|
|
# the *worst case* is ~30KB/s/client. Again, for normal use-cases this
|
|
# is actually barely noticeable.
|
|
setRawDelay=0.2
|
|
}
|
|
|
|
# Settings for mod integration (the mod previously known as OpenComponents).
|
|
integration {
|
|
buildcraft {
|
|
|
|
# Cost to convert a loot disk to another in the BuildCraft programming table.
|
|
programmingTableCost=5000
|
|
}
|
|
|
|
# The name to use for the global fake player needed for some mod
|
|
# interactions.
|
|
fakePlayerName="[OpenComputers]"
|
|
|
|
# The UUID to use for the global fake player needed for some mod
|
|
# interactions.
|
|
fakePlayerUuid="7e506b5d-2ccb-4ac4-a249-5624925b0c67"
|
|
|
|
# A list of mods (by mod id) for which support should NOT be enabled. Use
|
|
# this to disable support for mods you feel should not be controllable via
|
|
# computers (such as magic related mods, which is why Thaumcraft is on this
|
|
# list by default.)
|
|
modBlacklist=[
|
|
Thaumcraft,
|
|
thaumicenergistics
|
|
]
|
|
|
|
# A list of tile entities by class name that should NOT be accessible via
|
|
# the Adapter block. Add blocks here that can lead to crashes or deadlocks
|
|
# (and report them, please!)
|
|
peripheralBlacklist=[
|
|
"net.minecraft.tileentity.TileEntityCommandBlock"
|
|
]
|
|
|
|
# Vanilla integration related settings.
|
|
vanilla {
|
|
|
|
# Whether to allow the item stack converter to push NBT data in
|
|
# compressed format (GZIP'ed). This can be useful for pushing this
|
|
# data back to other callbacks. However, given a sophisticated
|
|
# enough software (Lua script) it is possible to decode this data,
|
|
# and get access to things that should be considered implementation
|
|
# detail / private (mods may keep "secret" data in such NBT tags).
|
|
# The recommended method is to use the database component instead.
|
|
allowItemStackNBTTags=false
|
|
|
|
# Whether to enable the command block driver. Enabling this allows
|
|
# computers to set and execute commands via command blocks next to
|
|
# adapter blocks. The commands are run using OC's general fake player.
|
|
enableCommandBlockDriver=false
|
|
|
|
# Whether to enable the inventory driver. This driver allows interacting
|
|
# with inventories adjacent to adapters in a way similar to what the
|
|
# inventory controller upgrade allows when built into a robot or placed
|
|
# inside an adapter. It is therefore considered to be somewhat cheaty by
|
|
# some, and disabled by default. If you don't care about that, feel free
|
|
# to enable this driver.
|
|
enableInventoryDriver=false
|
|
|
|
# Whether to enable the tank driver. This driver is like the inventory
|
|
# driver, just for fluid tanks, and is disabled by default with the same
|
|
# reasoning as the inventory driver - using a tank controller upgrade in
|
|
# an adapter has pretty much the same effect.
|
|
enableTankDriver=false
|
|
}
|
|
}
|
|
|
|
# Internet settings, security related.
|
|
internet {
|
|
|
|
# This is a list of blacklisted domain names. If an HTTP request is made
|
|
# or a socket connection is opened the target address will be compared
|
|
# to the addresses / address ranges in this list. It it is present in this
|
|
# list, the request will be denied.
|
|
# Entries are either domain names (www.example.com) or IP addresses in
|
|
# string format (10.0.0.3), optionally in CIDR notation to make it easier
|
|
# to define address ranges (1.0.0.0/8). Domains are resolved to their
|
|
# actual IP once on startup, future requests are resolved and compared
|
|
# to the resolved addresses.
|
|
# By default all local addresses are blocked. This is only meant as a
|
|
# thin layer of security, to avoid average users hosting a game on their
|
|
# local machine having players access services in their local network.
|
|
# Server hosters are expected to configure their network outside of the
|
|
# mod's context in an appropriate manner, e.g. using a system firewall.
|
|
blacklist=[
|
|
"127.0.0.0/8",
|
|
"10.0.0.0/8",
|
|
"192.168.0.0/16",
|
|
"172.16.0.0/12"
|
|
]
|
|
|
|
# Whether to allow HTTP requests via internet cards. When enabled,
|
|
# the `request` method on internet card components becomes available.
|
|
enableHttp=true
|
|
|
|
# Whether to allow adding custom headers to HTTP requests.
|
|
enableHttpHeaders=true
|
|
|
|
# Whether to allow TCP connections via internet cards. When enabled,
|
|
# the `connect` method on internet card components becomes available.
|
|
enableTcp=true
|
|
|
|
# The maximum concurrent TCP connections *each* internet card can have
|
|
# open at a time.
|
|
maxTcpConnections=4
|
|
|
|
# The time in seconds to wait for a response to a request before timing
|
|
# out and returning an error message. If this is zero (the default) the
|
|
# request will never time out.
|
|
requestTimeout=0
|
|
|
|
# The number of threads used for processing host name lookups and HTTP
|
|
# requests in the background. The more there are, the more concurrent
|
|
# connections can potentially be opened by computers, and the less likely
|
|
# they are to delay each other.
|
|
threads=4
|
|
|
|
# This is a list of whitelisted domain names. Requests may only be made
|
|
# to addresses that are present in this list. If this list is empty,
|
|
# requests may be made to all addresses not blacklisted. Note that the
|
|
# blacklist is always applied, so if an entry is present in both the
|
|
# whitelist and the blacklist, the blacklist will win.
|
|
# Entries are of the same format as in the blacklist. Examples:
|
|
# "gist.github.com", "www.pastebin.com"
|
|
whitelist=[]
|
|
}
|
|
|
|
# Other settings that you might find useful to tweak.
|
|
misc {
|
|
|
|
# Allow robots to get a table representation of item stacks using the
|
|
# inventory controller upgrade? (i.e. whether the getStackInSlot method
|
|
# of said upgrade is enabled or not). Also applies to tank controller
|
|
# upgrade and it's fluid getter method.
|
|
allowItemStackInspection=true
|
|
|
|
# List of item descriptors of assembler template base items to blacklist,
|
|
# i.e. for disabling the assembler template for. Entries must be of the
|
|
# format 'itemid@damage', were the damage is optional.
|
|
# Examples: 'OpenComputers:case3', 'minecraft:stonebrick@1'
|
|
assemblerBlacklist=[]
|
|
|
|
# Hard limit for size of byte arrays passed to data card callbacks. If this
|
|
# limit is exceeded, the call fails and does nothing.
|
|
dataCardHardLimit=1048576
|
|
|
|
# Soft limit for size of byte arrays passed to data card callbacks. If this
|
|
# limit is exceeded, a longer sleep is enforced (see dataCardTimeout).
|
|
dataCardSoftLimit=8192
|
|
|
|
# Time in seconds to pause a calling machine when the soft limit for a data
|
|
# card callback is exceeded.
|
|
dataCardTimeout=1
|
|
|
|
# By default the disassembler can only be used to disassemble items from
|
|
# OpenComputers itself (or objects whitelisted via the API). If you'd
|
|
# like to allow the disassembler to work on all kinds of items, even from
|
|
# other mods, set this to true.
|
|
disassembleAllTheThings=false
|
|
|
|
# The probability that an item breaks when disassembled. This chance
|
|
# applies *per extracted item*. For example, if an item was crafted from
|
|
# three other items and gets disassembled, each of those three items has
|
|
# this chance of breaking in the process.
|
|
disassemblerBreakChance=0.05
|
|
|
|
# Names of items / blocks that are blacklisted. Recipes containing these
|
|
# as inputs will be ignored by the disassembler.
|
|
disassemblerInputBlacklist=[
|
|
"minecraft:fire"
|
|
]
|
|
|
|
# Controls how noisy results from the Geolyzer are. This is the maximum
|
|
# deviation from the original value at the maximum vertical distance
|
|
# from the geolyzer. Noise increases linearly with the euclidean distance
|
|
# to the Geolyzer.
|
|
geolyzerNoise=2
|
|
|
|
# The range, in blocks, in which the Geolyzer can scan blocks. Note that
|
|
# it uses the maximum-distance, not the euclidean one, i.e. it can scan
|
|
# in a cube surrounding it with twice this value as its edge length.
|
|
geolyzerRange=32
|
|
|
|
# Whether to give a new player a free copy of the manual. This will only
|
|
# happen one time per game, not per world, not per death. Once. If this
|
|
# is still too much for your taste, disable it here ;-)
|
|
giveManualToNewPlayers=true
|
|
|
|
# Whether to not show your special thinger (if you have one you know it).
|
|
hideOwnSpecial=false
|
|
|
|
# Whether to pass along the name of the user that caused an input signals
|
|
# to the computer (mouse and keyboard signals). If you feel this breaks
|
|
# the game's immersion, disable it.
|
|
# Note: also applies to the motion sensor.
|
|
inputUsername=true
|
|
|
|
# The probability (or rather, weighted chance) that a program disk is
|
|
# spawned as loot in a treasure chest. For reference, iron ingots have
|
|
# a value of 10, gold ingots a value of 5 and and diamonds a value of 3.
|
|
# This is the chance *that* a disk is created. Which disk that will be
|
|
# is decided in an extra roll of the dice.
|
|
lootProbability=5
|
|
|
|
# Whether to allow loot disk cycling by crafting them with a wrench.
|
|
lootRecrafting=true
|
|
|
|
# The maximum length of a string that may be pasted. This is used to limit
|
|
# the size of the data sent to the server when the user tries to paste a
|
|
# string from the clipboard (Shift+Ins on a screen with a keyboard).
|
|
maxClipboard=1024
|
|
|
|
# The maximum number of "data parts" a network packet is allowed to have.
|
|
# When sending a network message, from Lua this may look like so:
|
|
# component.modem.broadcast(port, "first", true, "third", 123)
|
|
# This limits how many arguments can be passed and are wrapped into a
|
|
# packet. This limit mostly serves as a protection for lower-tier
|
|
# computers, to avoid them getting nuked by more powerful computers.
|
|
maxNetworkPacketParts=8
|
|
|
|
# The maximum size of network packets to allow sending via network cards.
|
|
# This has *nothing to do* with real network traffic, it's just a limit
|
|
# for the network cards, mostly to reduce the chance of computer with a
|
|
# lot of RAM killing those with less by sending huge packets. This does
|
|
# not apply to HTTP traffic.
|
|
maxNetworkPacketSize=8192
|
|
|
|
# The maximum number of ports a single network card can have opened at
|
|
# any given time.
|
|
# Note that the order for this list is: Wired Network Card -> Tier 1 Wireless
|
|
# Network Card -> Tier 2 Wireless Network Card
|
|
maxOpenPorts=[
|
|
16,
|
|
1,
|
|
16
|
|
]
|
|
|
|
# The maximum height of multi-block screens, in blocks. This is limited to
|
|
# avoid excessive computations for merging screens. If you really need
|
|
# bigger screens it's probably safe to bump this quite a bit before you
|
|
# notice anything, since at least incremental updates should be very
|
|
# efficient (i.e. when adding/removing a single screen).
|
|
maxScreenHeight=6
|
|
|
|
# The maximum width of multi-block screens, in blocks.
|
|
# See also: `maxScreenHeight`.
|
|
maxScreenWidth=8
|
|
|
|
# The maximum distance a wireless message can be sent. In other words,
|
|
# this is the maximum signal strength a wireless network card supports.
|
|
# This is used to limit the search range in which to check for modems,
|
|
# which may or may not lead to performance issues for ridiculous ranges -
|
|
# like, you know, more than the loaded area.
|
|
# See also: `wirelessCostPerRange`.
|
|
# These values are for the tier 1 and 2 wireless cards, in that order.
|
|
maxWirelessRange=[
|
|
16,
|
|
400
|
|
]
|
|
|
|
# Radius the MFU is able to operate in
|
|
mfuRange=3
|
|
|
|
# Probablility that at certain celebratory times crafting an OC item will
|
|
# spawn a present in the crafting player's inventory. Set to zero to
|
|
# disable.
|
|
presentChance=0.05
|
|
|
|
# Enforced delay when changing a redstone emitting component's output,
|
|
# such as the redstone card and redstone I/O block. Lowering this can
|
|
# have very negative impact on server TPS, so beware.
|
|
redstoneDelay=0.1
|
|
|
|
# The general upgrade tier of the switch built into server racks, i.e. how
|
|
# upgraded server racks' switching logic is. Prior to the introduction of
|
|
# this setting (1.5.15) this was always none. This applies to all
|
|
# properties, i.e. througput, frequency and buffer size.
|
|
# Valid values are: 0 = none, 1 = tier 1, 2 = tier 2, 3 = tier 3.
|
|
serverRackSwitchTier=1
|
|
|
|
# The number of remote terminals supported by each server tier.
|
|
terminalsPerTier=[
|
|
2,
|
|
4,
|
|
8
|
|
]
|
|
|
|
# Override for the worker threads' thread priority. If set to a value
|
|
# lower than 1 it will use the default value, which is half-way between
|
|
# the system minimum and normal priority. Valid values may differ between
|
|
# Java versions, but usually the minimum value (lowest priority) is 1,
|
|
# the normal value is 5 and the maximum value is 10. If a manual value is
|
|
# given it is automatically capped at the maximum.
|
|
# USE THIS WITH GREAT CARE. Using a high priority for worker threads may
|
|
# avoid issues with computers timing out, but can also lead to higher
|
|
# server load. AGAIN, USE WITH CARE!
|
|
threadPriority=-1
|
|
|
|
# The maximum range between the drone/robot and a villager for a trade to
|
|
# be performed by the trading upgrade
|
|
tradingRange=8
|
|
|
|
# Whether to perform an update check and informing local players and OPs
|
|
# if a new version is available (contacts Github once the first player
|
|
# joins a server / the first map in single player is opened).
|
|
updateCheck=true
|
|
}
|
|
|
|
# Nanomachine related values. Note that most of these are relative, as
|
|
# they scale with the number of total effects controlled by nanomachines,
|
|
# which may very much vary depending on other mods used together with OC.
|
|
# To configure this, you'll need to know how this works a bit more in-
|
|
# depth, so here goes: there are three layers, the behavior layer, the
|
|
# connector layer, and the input layer. The behavior layer consists of
|
|
# one node for each behavior provided by registered providers (by default
|
|
# these will be potion effects and a few other things). The connector
|
|
# layer merely serves to mix things up a little. The input layer is made
|
|
# up from nodes that can be triggered by the nanomachines. Each connector
|
|
# node has behavior nodes it outputs to, and gets signals from input nodes.
|
|
# Behavior nodes get signals from both the connector and the input layers.
|
|
# Reconfiguring builds up random connections. Some behaviors change what
|
|
# they do based on the number of active inputs (e.g. potion effects will
|
|
# increase their amplification value).
|
|
nanomachines {
|
|
|
|
# Time in seconds it takes for the nanomachines to process a command
|
|
# and send a response.
|
|
commandDelay=1
|
|
|
|
# The distance in blocks that nanomachines can communicate within. If
|
|
# a message comes from further away, it'll be ignored. When responding,
|
|
# the response will only be sent this far.
|
|
commandRange=2
|
|
|
|
# The relative number of connectors based on the number of available
|
|
# behaviors (see triggerQuota).
|
|
connectorQuota=0.2
|
|
|
|
# Radius in blocks of the disintegration behavior for each active input.
|
|
disintegrationRange=1
|
|
|
|
# How much damage the hungry behavior should deal to the player when the
|
|
# nanomachine controller runs out of energy.
|
|
hungryDamage=5
|
|
|
|
# How much energy the hungry behavior should restore when damaging the
|
|
# player.
|
|
hungryEnergyRestored=50
|
|
|
|
# Range of the item magnet behavior added for each active input.
|
|
magnetRange=8
|
|
|
|
# The maximum number of inputs for each node of the "neural network"
|
|
# nanomachines connect to. I.e. each behavior node and connector node
|
|
# may only have up to this many inputs.
|
|
maxInputs=2
|
|
|
|
# Hard maximum number of active inputs. This is mainly to avoid people
|
|
# bumping other nanomachines' inputs to max, killing them in a matter
|
|
# of (milli)seconds.
|
|
maxInputsActive=4
|
|
|
|
# The maximum number of outputs for each node (see maxInputs).
|
|
maxOutputs=2
|
|
|
|
# Whitelisted potions, i.e. potions that will be used for the potion
|
|
# behaviors nanomachines may trigger. This can contain strings or numbers.
|
|
# In the case of strings, it has to be the internal name of the potion,
|
|
# in case of a number it has to be the potion ID. Add any potion effects
|
|
# to make use of here, since they will all be disabled by default.
|
|
potionWhitelist=[
|
|
speed,
|
|
haste,
|
|
strength,
|
|
"jump_boost",
|
|
resistance,
|
|
"fire_resistance",
|
|
"water_breathing",
|
|
"night_vision",
|
|
absorption,
|
|
blindness,
|
|
nausea,
|
|
"mining_fatigue",
|
|
"instant_damage",
|
|
hunger,
|
|
slowness,
|
|
poison,
|
|
weakness,
|
|
wither
|
|
]
|
|
|
|
# How many input nodes may be active at the same time before negative
|
|
# effects are applied to the player.
|
|
safeInputsActive=2
|
|
|
|
# The relative amount of triggers available based on the number of
|
|
# available behaviors (such as different potion effects). For example,
|
|
# if there are a total of 10 behaviors available, 0.5 means there will
|
|
# be 5 trigger inputs, triggers being the inputs that can be activated
|
|
# via nanomachines.
|
|
triggerQuota=0.4
|
|
}
|
|
|
|
# Power settings, buffer sizes and power consumption.
|
|
power {
|
|
|
|
# The amount of energy the robot assembler can apply per tick. This
|
|
# controls the speed at which robots are assembled, basically.
|
|
assemblerTickAmount=50
|
|
|
|
# Default "buffer" sizes, i.e. how much energy certain blocks can store.
|
|
buffer {
|
|
|
|
# The amount of energy an access point can store.
|
|
accessPoint=600
|
|
|
|
# The amount of energy a capacitor can store when installed as an
|
|
# upgrade into a robot.
|
|
batteryUpgrades=[
|
|
10000,
|
|
15000,
|
|
20000
|
|
]
|
|
|
|
# The amount of energy a single capacitor can store.
|
|
capacitor=1600
|
|
|
|
# The amount of bonus energy a capacitor can store for each other
|
|
# capacitor it shares a face with. This bonus applies to both of the
|
|
# involved capacitors. It reaches a total of two blocks, where the
|
|
# bonus is halved for the second neighbor. So three capacitors in a
|
|
# row will give a total of 8.8k storage with default values:
|
|
# (1.6 + 0.8 + 0.4)k + (0.8 + 1.6 + 0.8)k + (0.4 + 0.8 + 1.6)k
|
|
capacitorAdjacencyBonus=800
|
|
|
|
# The amount of energy a computer can store. This allows you to get a
|
|
# computer up and running without also having to build a capacitor.
|
|
computer=500
|
|
|
|
# The amount of energy a converter can store. This allows directly
|
|
# connecting a converter to a distributor, without having to have a
|
|
# capacitor on the side of the converter.
|
|
converter=1000
|
|
|
|
# The amount of energy each face of a distributor can store. This
|
|
# allows connecting two power distributors directly. If the buffer
|
|
# capacity between the two distributors is zero, they won't be able
|
|
# to exchange energy. This basically controls the bandwidth. You can
|
|
# add capacitors between two distributors to increase this bandwidth.
|
|
distributor=500
|
|
|
|
# The amount of energy a drone can store in its internal buffer.
|
|
drone=5000
|
|
|
|
# The internal buffer size of the hover boots.
|
|
hoverBoots=15000
|
|
|
|
# The amount of energy a microcontroller can store in its internal
|
|
# buffer.
|
|
mcu=1000
|
|
|
|
# Amount of energy stored by nanomachines. Yeah, I also don't know
|
|
# where all that energy is stored. It's quite fascinating.
|
|
nanomachines=100000
|
|
|
|
# The amount of energy robots can store in their internal buffer.
|
|
robot=20000
|
|
|
|
# The amount a tablet can store in its internal buffer.
|
|
tablet=10000
|
|
}
|
|
|
|
# Carpeted Capacitor settings
|
|
# Carpeted Capacitors generate power when sheep or ocelots walk on them
|
|
# Power is generated when at least 2 of a type of animal are present.
|
|
# A single sheep and a single ocelot generates no power. Note that a
|
|
# computer constantly flashing the screen from white to black drains
|
|
# approximately 36 units of power per second. Thus, as an example with the
|
|
# default values, it would take 12 carpeted capacitors and 24 sheep
|
|
# (2 each) to keep the charge rate. Or, 6 carpeted capacitors and 12
|
|
# ocelots to do the same. Values are: units of power per carpeted
|
|
# capacitor per second with 2 animals of a type.
|
|
carpetedCapacitors {
|
|
|
|
# Chance one animal (per capacitor) will take some damage per minute
|
|
# Damage chance is only dealt when power is generated
|
|
damageChance=0.001
|
|
|
|
# power generated from ocelots
|
|
ocelotPower=6
|
|
|
|
# power generated from sheep
|
|
sheepPower=3
|
|
}
|
|
|
|
# The amount of energy a Charger transfers to each adjacent robot per tick
|
|
# if a maximum strength redstone signal is set. Chargers load robots with
|
|
# a controllable speed, based on the maximum strength of redstone signals
|
|
# going into the block. So if a redstone signal of eight is set, it'll
|
|
# charge robots at roughly half speed.
|
|
chargerChargeRate=100
|
|
|
|
# The amount of energy a Charger transfers into a tablet, if present, per
|
|
# tick. This is also based on configured charge speed, as for robots.
|
|
chargerChargeRateTablet=10
|
|
|
|
# Default "costs", i.e. how much energy certain operations consume.
|
|
cost {
|
|
|
|
# The cost of a single packet sent via StargateTech 2's abstract bus.
|
|
abstractBusPacket=1
|
|
|
|
# The amount of energy the chunkloader upgrade draws per tick while
|
|
# it is enabled, i.e. actually loading a chunk.
|
|
chunkloaderCost=0.06
|
|
|
|
# The amount of energy a computer consumes per tick when running.
|
|
computer=0.5
|
|
|
|
# Cost for asymmetric operations on the data card, such as ECDH and ECDSA
|
|
# Per-byte cost for ECDSA operation is controlled by `complex` value,
|
|
# because data is hashed with SHA256 before signing/verifying
|
|
dataCardAsymmetric=10
|
|
|
|
# Cost for complex operations on the data card, such as SHA256, inflate/deflate and SecureRandom.
|
|
dataCardComplex=6
|
|
|
|
# Per-byte cost for complex operations
|
|
dataCardComplexByte=0.1
|
|
|
|
# Cost for simple operations on the data card, such as MD5 or AES
|
|
dataCardSimple=1
|
|
|
|
# Per-byte cost for simple operations
|
|
dataCardSimpleByte=0.01
|
|
|
|
# Cost for trivial operations on the data card, such as CRC32 or Base64
|
|
dataCardTrivial=0.2
|
|
|
|
# Per-byte cost for trivial operations
|
|
dataCardTrivialByte=0.005
|
|
|
|
# The amount of energy it takes to extract one ingredient from an
|
|
# item that is being disassembled. For example, if an item that was
|
|
# crafted from three other items gets disassembled, a total of 15000
|
|
# energy will be required by default.
|
|
# Note that this is consumed over time, and each time this amount is
|
|
# reached *one* ingredient gets ejected (unless it breaks, see the
|
|
# disassemblerBreakChance setting).
|
|
disassemblerPerItem=2000
|
|
|
|
# The amount of energy a drone consumes per tick when running.
|
|
drone=0.4
|
|
|
|
# The base energy cost for assembling a drone.
|
|
droneAssemblyBase=25000
|
|
|
|
# The additional amount of energy required to assemble a
|
|
# drone for each point of complexity.
|
|
droneAssemblyComplexity=15000
|
|
|
|
# Energy it costs to re-program an EEPROM. This is deliberately
|
|
# expensive, to discourage frequent re-writing of EEPROMs.
|
|
eepromWrite=50
|
|
|
|
# How much energy is consumed when the Geolyzer scans a block.
|
|
geolyzerScan=10
|
|
|
|
# Energy it takes to clear a basic screen using the fill command with
|
|
# 'space' as the fill char.
|
|
# Note: internally this is adjusted to a cost per pixel, and applied
|
|
# as such, so this also implicitly defines the cost for higher tier
|
|
# screens.
|
|
gpuClear=0.1
|
|
|
|
# Energy it takes to copy half of a basic screen via the copy command.
|
|
# Note: internally this is adjusted to a cost per pixel, and applied
|
|
# as such, so this also implicitly defines the cost for higher tier
|
|
# screens.
|
|
gpuCopy=0.25
|
|
|
|
# Energy it takes to change a basic screen with the fill command.
|
|
# Note: internally this is adjusted to a cost per pixel, and applied
|
|
# as such, so this also implicitly defines the cost for higher tier
|
|
# screens.
|
|
gpuFill=1
|
|
|
|
# Energy it takes to change *every* 'pixel' via the set command of a
|
|
# basic screen via the `set` command.
|
|
# Note: internally this is adjusted to a cost per pixel, and applied
|
|
# as such, so this also implicitly defines the cost for higher tier
|
|
# screens.
|
|
gpuSet=2
|
|
|
|
# Energy it takes read one kilobyte from a file system. Note that non
|
|
# I/O operations on file systems such as `list` or `getFreeSpace` do
|
|
# *not* consume power. Note that this very much determines how much
|
|
# energy you need in store to start a computer, since you need enough
|
|
# to have the computer read all the libraries, which is around 60KB
|
|
# at the time of writing.
|
|
# Note: internally this is adjusted to a cost per byte, and applied
|
|
# as such. It's just specified per kilobyte to be more intuitive.
|
|
hddRead=0.1
|
|
|
|
# Energy it takes to write one kilobyte to a file system.
|
|
# Note: internally this is adjusted to a cost per byte, and applied
|
|
# as such. It's just specified per kilobyte to be more intuitive.
|
|
hddWrite=0.25
|
|
|
|
# The amount of energy a hologram projetor consumes per tick. This
|
|
# is the cost if every column is lit. If not a single voxel is
|
|
# displayed the hologram projector will not drain energy.
|
|
hologram=0.2
|
|
|
|
# The amount of energy consumed when the hover boots absorb some fall
|
|
# velocity (i.e. when falling from something higher than three blocks).
|
|
hoverBootAbsorb=10
|
|
|
|
# The amount of energy consumed when jumping with the hover boots. Only
|
|
# applies when the jump boost is applied, i.e. when not sneaking.
|
|
hoverBootJump=10
|
|
|
|
# The amount of energy consumed *per second* when moving around while
|
|
# wearing the hover boots. This is compensate for the step assist, which
|
|
# does not consume energy on a per-use basis. When standing still or
|
|
# moving very slowly this also does not trigger.
|
|
hoverBootMove=1
|
|
|
|
# Energy consumed by a MFU per tick while connected.
|
|
# Similarly to `wirelessCostPerRange`, this is multiplied with the distance to the bound block.
|
|
mfuRelay=1
|
|
|
|
# Amount of energy a microcontroller consumes per tick while running.
|
|
microcontroller=0.1
|
|
|
|
# The base energy cost for assembling a microcontroller.
|
|
microcontrollerAssemblyBase=10000
|
|
|
|
# The additional amount of energy required to assemble a
|
|
# microcontroller for each point of complexity.
|
|
microcontrollerAssemblyComplexity=10000
|
|
|
|
# Energy consumed per tick per active input node by nanomachines.
|
|
nanomachineInput=0.5
|
|
|
|
# Energy consumed when reconfiguring nanomachines.
|
|
nanomachinesReconfigure=5000
|
|
|
|
# The amount of energy pushing blocks with the piston upgrade costs.
|
|
pistonPush=20
|
|
|
|
# How much energy is required for a single 3D print.
|
|
printerModel=100
|
|
|
|
# The amount of energy a robot consumes per tick when running. This is
|
|
# per default less than a normal computer uses because... well... they
|
|
# are better optimized? It balances out due to the cost for movement,
|
|
# interaction and whatnot, and the fact that robots cannot connect to
|
|
# component networks directly, so they are no replacements for normal
|
|
# computers.
|
|
robot=0.25
|
|
|
|
# The base energy cost for assembling a robot.
|
|
robotAssemblyBase=50000
|
|
|
|
# The additional amount of energy required to assemble a robot for
|
|
# each point of complexity.
|
|
robotAssemblyComplexity=10000
|
|
|
|
# The conversion rate of exhaustion from using items to energy
|
|
# consumed. Zero means exhaustion does not require energy, one is a
|
|
# one to one conversion. For example, breaking a block generates 0.025
|
|
# exhaustion, attacking an entity generates 0.3 exhaustion.
|
|
robotExhaustion=10
|
|
|
|
# The amount of energy it takes a robot to move a single block.
|
|
robotMove=15
|
|
|
|
# The amount of energy it takes a robot to perform a 90 degree turn.
|
|
robotTurn=2.5
|
|
|
|
# The amount of energy a screen consumes per tick. For each lit pixel
|
|
# (each character that is not blank) this cost increases linearly:
|
|
# for basic screens, if all pixels are lit the cost per tick will be
|
|
# this value. Higher tier screens can become even more expensive to
|
|
# run, due to their higher resolution. If a screen cannot consume the
|
|
# defined amount of energy it will stop rendering the text that
|
|
# should be displayed on it. It will *not* forget that text, however,
|
|
# so when enough power is available again it will restore the
|
|
# previously displayed text (with any changes possibly made in the
|
|
# meantime). Note that for multi-block screens *each* screen that is
|
|
# part of it will consume this amount of energy per tick.
|
|
screen=0.05
|
|
|
|
# The actual cost per tick for computers and robots is multiplied
|
|
# with this value if they are currently in a "sleeping" state. They
|
|
# enter this state either by calling `os.sleep()` or by pulling
|
|
# signals. Note that this does not apply in the tick they resume, so
|
|
# you can't fake sleep by calling `os.sleep(0)`.
|
|
sleepFactor=0.1
|
|
|
|
# The base energy cost for assembling a tablet.
|
|
tabletAssemblyBase=20000
|
|
|
|
# The additional amount of energy required to assemble a tablet for
|
|
# each point of complexity.
|
|
tabletAssemblyComplexity=5000
|
|
|
|
# Energy required for one transposer operation (regardless of the number
|
|
# of items / fluid volume moved).
|
|
transposer=1
|
|
|
|
# The amount of energy it costs to send a wireless message with signal
|
|
# strength one, which means the signal reaches one block. This is
|
|
# scaled up linearly, so for example to send a signal 400 blocks a
|
|
# signal strength of 400 is required, costing a total of
|
|
# 400 * `wirelessCostPerRange`. In other words, the higher this value,
|
|
# the higher the cost of wireless messages.
|
|
# See also: `maxWirelessRange`.
|
|
# These values are for the tier 1 and 2 wireless cards, in that order.
|
|
wirelessCostPerRange=[
|
|
0.05,
|
|
0.05
|
|
]
|
|
}
|
|
|
|
# The amount of energy the disassembler can apply per tick. This
|
|
# controls the speed at which items are disassembled, basically.
|
|
disassemblerTickAmount=25
|
|
|
|
# The energy efficiency of the generator upgrade. At 1.0 this will
|
|
# generate as much energy as you'd get by burning the fuel in a BuildCraft
|
|
# Stirling Engine (1MJ per fuel value / burn ticks). To discourage fully
|
|
# autonomous robots the efficiency of generators is slighly reduced by
|
|
# default.
|
|
generatorEfficiency=0.8
|
|
|
|
# Whether to ignore any power requirements. Whenever something requires
|
|
# power to function, it will try to get the amount of energy it needs from
|
|
# the buffer of its connector node, and in case it fails it won't perform
|
|
# the action / trigger a shutdown / whatever. Setting this to `true` will
|
|
# simply make the check 'is there enough energy' succeed unconditionally.
|
|
# Note that buffers are still filled and emptied following the usual
|
|
# rules, there just is no failure case anymore. The converter will however
|
|
# not accept power from other mods.
|
|
ignorePower=false
|
|
|
|
# If you don't want OpenComputers to accept power from one or more of the
|
|
# supported power mods, for example because it doesn't suit the vision
|
|
# of your mod pack, you can disable support for them here. To stop
|
|
# OpenComputers accepting power from a mod, enter its mod id here, e.g.
|
|
# `BuildCraftAPI|power`, `IC2`, `factorization`, ...
|
|
modBlacklist=[]
|
|
|
|
# The amount of energy the printer can apply per tick. This controls
|
|
# the speed at which prints are completed, basically.
|
|
printerTickAmount=1
|
|
|
|
# The rate at which different blocks accept external power. All of these
|
|
# values are in OC energy / tick.
|
|
rate {
|
|
accessPoint=10
|
|
assembler=100
|
|
case=[
|
|
5,
|
|
10,
|
|
20
|
|
]
|
|
charger=200
|
|
disassembler=50
|
|
powerConverter=500
|
|
serverRack=50
|
|
}
|
|
|
|
# The energy efficiency of the solar generator upgrade. At 1.0 this will
|
|
# generate as much energy as you'd get by burning fuel in a BuildCraft
|
|
# Stirling Engine . To discourage fully autonomous robots the efficiency
|
|
# of solar generators is greatly reduced by default.
|
|
solarGeneratorEfficiency=0.2
|
|
|
|
# This determines how often continuous power sinks try to actually try to
|
|
# consume energy from the network. This includes computers, robots and
|
|
# screens. This also controls how frequent distributors revalidate their
|
|
# global state and secondary distributors, as well as how often the power
|
|
# converter queries sources for energy (for now: only BuildCraft). If set
|
|
# to 1, this would query every tick. The default queries every 10 ticks,
|
|
# or in other words twice per second.
|
|
# Higher values mean more responsive power consumption, but slightly more
|
|
# work per tick (shouldn't be that noticeable, though). Note that this
|
|
# has no influence on the actual amount of energy required by computers
|
|
# and screens. The power cost is directly scaled up accordingly:
|
|
# `tickFrequency * cost`.
|
|
tickFrequency=10
|
|
|
|
# Power values for different power systems. For reference, the value of
|
|
# OC's internal energy type is 1000. I.e. the conversion ratios are the
|
|
# values here divided by 1000. This is mainly to avoid small floating
|
|
# point numbers in the config, due to potential loss of precision.
|
|
value {
|
|
AppliedEnergistics2=200
|
|
Factorization=13
|
|
|
|
# same as RedstoneFlux
|
|
ForgeEnergy=100
|
|
Galacticraft=48
|
|
IndustrialCraft2=400
|
|
Mekanism=1333.33
|
|
PowerAdvantage=31.25
|
|
RedstoneFlux=100
|
|
|
|
# / 11256, same as AE2
|
|
RotaryCraft=200
|
|
}
|
|
}
|
|
|
|
# 3D printer related stuff.
|
|
printer {
|
|
|
|
# Whether Chamelium is edible or not. When eaten, it gives a (short)
|
|
# invisibility buff, and (slightly longer) blindness debuff.
|
|
chameliumEdible=true
|
|
|
|
# The extra material cost involved for printing a model with a customized
|
|
# redstone output, i.e. something in [1, 14].
|
|
customRedstoneCost=300
|
|
|
|
# The amount by which a printers ink buffer gets filled for a single
|
|
# cartridge. Tweak this if you think printing is too cheap or expensive.
|
|
# Note: the amount a single dye adds is this divided by 10.
|
|
inkValue=50000
|
|
|
|
# The amount by which a printers material buffer gets filled for a single
|
|
# chamelium. Tweak this if you think printing is too cheap or expensive.
|
|
materialValue=2000
|
|
|
|
# The maximum light level a printed block can emit. This defaults to
|
|
# a value similar to that of a redstone torch, because by default the
|
|
# material prints are made of contains redstone, but no glowstone.
|
|
# Prints' light level can further be boosted by crafting them with
|
|
# glowstone dust. This is merely the maximum light level that can be
|
|
# achieved directly when printing them.
|
|
maxBaseLightLevel=8
|
|
|
|
# The maximum number of shape for a state of a 3D print allowed. This is
|
|
# for the individual states (off and on), so it is possible to have up to
|
|
# this many shapes *per state* (the reasoning being that only one state
|
|
# will ever be visible at a time).
|
|
maxShapes=24
|
|
|
|
# By what (linear) factor the cost of a print increases if one or both of
|
|
# its states are non-collidable (i.e. entities can move through them).
|
|
# This only influences the chamelium cost.
|
|
noclipMultiplier=2
|
|
|
|
# Whether to enable print opacity, i.e. make prints have shadows. If
|
|
# enabled, prints will have an opacity that is estimated from their
|
|
# sampled fill rate. This is disabled by default, because MC's lighting
|
|
# computation is apparently not very happy with multiple blocks with
|
|
# dynamic opacity sitting next to each other, and since all prints share
|
|
# the same block type, this can lead to weird shadows on prints. If you
|
|
# don't care about that and prefer them to be not totally shadowless,
|
|
# enable this.
|
|
printsHaveOpacity=false
|
|
|
|
# How much of the material used to print a model is refunded when using
|
|
# the model to refuel a printer. This the value the original material
|
|
# cost is multiplied with, so 1 is a full refund, 0 disables the
|
|
# functionality (won't be able to put prints into the material input).
|
|
recycleRate=0.75
|
|
}
|
|
|
|
# Robot related settings, what they may do and general balancing.
|
|
robot {
|
|
|
|
# Whether robots may 'activate' blocks in the world. This includes
|
|
# pressing buttons and flipping levers, for example. Disable this if it
|
|
# causes problems with some mod (but let me know!) or if you think this
|
|
# feature is too over-powered.
|
|
allowActivateBlocks=true
|
|
|
|
# Whether robots may use items for a specifiable duration. This allows
|
|
# robots to use items such as bows, for which the right mouse button has
|
|
# to be held down for a longer period of time. For robots this works
|
|
# slightly different: the item is told it was used for the specified
|
|
# duration immediately, but the robot will not resume execution until the
|
|
# time that the item was supposedly being used has elapsed. This way
|
|
# robots cannot rapidly fire critical shots with a bow, for example.
|
|
allowUseItemsWithDuration=true
|
|
|
|
# Whether robots may damage players if they get in their way. This
|
|
# includes all 'player' entities, which may be more than just real players
|
|
# in the game.
|
|
canAttackPlayers=false
|
|
|
|
# Allows fine-tuning of delays for robot actions.
|
|
delays {
|
|
|
|
# The time in seconds to pause execution after an item was
|
|
# successfully dropped from a robot's inventory.
|
|
drop=0.5
|
|
|
|
# This is the *ratio* of the time a player would require to harvest a
|
|
# block. Note that robots cannot break blocks they cannot harvest. So
|
|
# the time a robot is forced to sleep after harvesting a block is
|
|
# breakTime * harvestRatio
|
|
# Breaking a block will always at least take one tick, 0.05 seconds.
|
|
harvestRatio=1
|
|
|
|
# The time in seconds to pause execution after a robot issued a
|
|
# successful move command. Note that this essentially determines how
|
|
# fast robots can move around, since this also determines the length
|
|
# of the move animation.
|
|
move=0.4
|
|
|
|
# The time in seconds to pause execution after a robot successfully
|
|
# placed an item from its inventory.
|
|
place=0.4
|
|
|
|
# The time in seconds to pause execution after a robot successfully
|
|
# picked up an item after triggering a suck command.
|
|
suck=0.5
|
|
|
|
# The time in seconds to pause execution after a robot successfully
|
|
# swung a tool (or it's 'hands' if nothing is equipped). Successful in
|
|
# this case means that it hit something, i.e. it attacked an entity or
|
|
# extinguishing fires.
|
|
# When breaking blocks the normal harvest time scaled with the
|
|
# `harvestRatio` (see below) applies.
|
|
swing=0.4
|
|
|
|
# The time in seconds to pause execution after a robot turned either
|
|
# left or right. Note that this essentially determines hw fast robots
|
|
# can turn around, since this also determines the length of the turn
|
|
# animation.
|
|
turn=0.4
|
|
|
|
# The time in seconds to pause execution after a robot successfully
|
|
# used an equipped tool (or it's 'hands' if nothing is equipped).
|
|
# Successful in this case means that it either used the equipped item,
|
|
# for example a splash potion, or that it activated a block, for
|
|
# example by pushing a button.
|
|
# Note that if an item is used for a specific amount of time, like
|
|
# when shooting a bow, the maximum of this and the duration of the
|
|
# item use is taken.
|
|
use=0.4
|
|
}
|
|
|
|
# The rate at which items used as tools by robots take damage. A value of
|
|
# one means that items lose durability as quickly as when they are used by
|
|
# a real player. A value of zero means they will not lose any durability
|
|
# at all. This only applies to items that can actually be damaged (such as
|
|
# swords, pickaxes, axes and shovels).
|
|
# Note that this actually is the *chance* of an item losing durability
|
|
# when it is used. Or in other words, it's the inverse chance that the
|
|
# item will be automatically repaired for the damage it just took
|
|
# immediately after it was used.
|
|
itemDamageRate=0.1
|
|
|
|
# Limit robot flight height, based on the following rules:
|
|
# - Robots may only move if the start or target position is valid (e.g.
|
|
# to allow building bridges).
|
|
# - The position below a robot is always valid (can always move down).
|
|
# - Positions up to <flightHeight> above a block are valid (limited
|
|
# flight capabilities).
|
|
# - Any position that has an adjacent block with a solid face towards the
|
|
# position is valid (robots can "climb").
|
|
# Set this to 256 to allow robots to fly whereever, as was the case
|
|
# before the 1.5 update. Consider using drones for cases where you need
|
|
# unlimited flight capabilities instead!
|
|
limitFlightHeight=8
|
|
|
|
# The name format to use for robots. The substring '$player$' is
|
|
# replaced with the name of the player that owns the robot, so for the
|
|
# first robot placed this will be the name of the player that placed it.
|
|
# This is transitive, i.e. when a robot in turn places a robot, that
|
|
# robot's owner, too, will be the owner of the placing robot.
|
|
# The substring $random$ will be replaced with a random number in the
|
|
# interval [1, 0xFFFFFF], which may be useful if you need to differentiate
|
|
# individual robots.
|
|
# If a robot is placed by something that is not a player, e.g. by some
|
|
# block from another mod, the name will default to 'OpenComputers'.
|
|
nameFormat="$player$.robot"
|
|
|
|
# Determines whether robots are a pretty cool guy. Ususally cobwebs are
|
|
# the bane of anything using a tool other than a sword or shears. This is
|
|
# an utter pain in the part you sit on, because it makes robots meant to
|
|
# dig holes utterly useless: the poor things couldn't break cobwebs in
|
|
# mining shafts with their golden pick axes. So, if this setting is true,
|
|
# we check for cobwebs and allow robots to break 'em anyway, no matter
|
|
# their current tool. After all, the hardness value of cobweb can only
|
|
# rationally explained by Steve's fear of spiders, anyway.
|
|
notAfraidOfSpiders=true
|
|
|
|
# The 'range' of robots when swinging an equipped tool (left click). This
|
|
# is the distance to the center of block the robot swings the tool in to
|
|
# the side the tool is swung towards. I.e. for the collision check, which
|
|
# is performed via ray tracing, this determines the end point of the ray
|
|
# like so: `block_center + unit_vector_towards_side * swingRange`
|
|
# This defaults to a value just below 0.5 to ensure the robots will not
|
|
# hit anything that's actually outside said block.
|
|
swingRange=0.49
|
|
|
|
# The maximum flight height with upgrades, tier one and tier two of the
|
|
# hover upgrade, respectively.
|
|
upgradeFlightHeight=[
|
|
64,
|
|
256
|
|
]
|
|
|
|
# The 'range' of robots when using an equipped tool (right click) or when
|
|
# placing items from their inventory. See `robot.swingRange`. This
|
|
# defaults to a value large enough to allow robots to detect 'farmland',
|
|
# i.e. tilled dirt, so that they can plant seeds.
|
|
useAndPlaceRange=0.65
|
|
|
|
# Controls the UUID robots are given. You can either specify a fixed UUID
|
|
# here or use the two provided variables:
|
|
# - $random$, which will assign each robot a random UUID.
|
|
# - $player$, which assigns to each placed robot the UUID of the player
|
|
# that placed it (note: if robots are placed by fake players, i.e.
|
|
# other mods' blocks, they will get that mods' fake player's profile!)
|
|
# Note that if no player UUID is available this will be the same as
|
|
# $random$.
|
|
uuidFormat="$player$"
|
|
|
|
# This controls how fast robots gain experience, and how that experience
|
|
# alters the stats.
|
|
xp {
|
|
|
|
# This controls how much experience a robot gains for each successful
|
|
# action it performs. "Actions" only include the following: swinging a
|
|
# tool and killing something or destroying a block and placing a block
|
|
# successfully. Note that a call to `swing` or `use` while "bare handed"
|
|
# will *not* gain a robot any experience.
|
|
actionXp=0.05
|
|
|
|
# The required amount per level is computed like this:
|
|
# xp(level) = baseValue + (level * constantGrowth) ^ exponentialGrowth
|
|
baseValue=50
|
|
|
|
# This is the amount of additional energy that fits into a robots
|
|
# internal buffer for each level it gains. So with the default values,
|
|
# at maximum level (30) a robot will have an internal buffer size of
|
|
# two hundred thousand.
|
|
bufferPerLevel=5000
|
|
|
|
# The required amount per level is computed like this:
|
|
# xp(level) = baseValue + (level * constantGrowth) ^ exponentialGrowth
|
|
constantGrowth=8
|
|
|
|
# This determines how much "exhaustion" contributes to a robots
|
|
# experience. This is additive to the "action" xp, so digging a block
|
|
# will per default give 0.05 + 0.025 [exhaustion] * 1.0 = 0.075 XP.
|
|
exhaustionXpRate=1
|
|
|
|
# The required amount per level is computed like this:
|
|
# xp(level) = baseValue + (level * constantGrowth) ^ exponentialGrowth
|
|
exponentialGrowth=2
|
|
|
|
# The increase in block harvest speed a robot gains per level. The time
|
|
# it takes to break a block is computed as actualTime * (1 - bonus).
|
|
# For example at level 20, with a bonus of 0.4 instead of taking 0.3
|
|
# seconds to break a stone block with a diamond pick axe it only takes
|
|
# 0.12 seconds.
|
|
harvestSpeedBoostPerLevel=0.02
|
|
|
|
# This determines how much experience a robot gets for each real XP orb
|
|
# an ore it harvested would have dropped. For example, coal is worth
|
|
# two real experience points, redstone is worth 5.
|
|
oreXpRate=4
|
|
|
|
# The additional "efficiency" a robot gains in using tools with each
|
|
# level. This basically increases the chances of a tool not losing
|
|
# durability when used, relative to the base rate. So for example, a
|
|
# robot with level 15 gets a 0.15 bonus, with the default damage rate
|
|
# that would lead to a damage rate of 0.1 * (1 - 0.15) = 0.085.
|
|
toolEfficiencyPerLevel=0.01
|
|
}
|
|
}
|
|
|
|
# Switch and access point network message forwarding logic related stuff.
|
|
switch {
|
|
|
|
# This is the size of the queue of a not upgraded switch. Increasing it
|
|
# avoids packets being dropped when many messages are sent in a single
|
|
# burst.
|
|
defaultMaxQueueSize=20
|
|
|
|
# The base number of packets that get relayed in one 'cycle'. The
|
|
# cooldown between cycles is determined by the delay.
|
|
defaultRelayAmount=1
|
|
|
|
# The delay a switch has by default between relaying packets (in ticks).
|
|
# WARNING: lowering this value will result in higher maximum CPU load,
|
|
# and may in extreme cases cause server lag.
|
|
defaultRelayDelay=5
|
|
|
|
# This is the amount by which the queue size increases per tier of the
|
|
# hard drive installed in the switch.
|
|
queueSizeUpgrade=10
|
|
|
|
# The number of additional packets that get relayed per cycle, based on
|
|
# the tier of RAM installed in the switch. For built-in RAM this
|
|
# increases by one per half-tier, for third-party ram this increases by
|
|
# two per item tier.
|
|
relayAmountUpgrade=1
|
|
|
|
# The amount of ticks the delay is *reduced* by per tier of the CPU
|
|
# inserted into a switch.
|
|
relayDelayUpgrade=1.5
|
|
}
|
|
|
|
# The version of OC this config was generated by. This is used to allow the
|
|
# mod to reset parts of the config when their meaning changed across
|
|
# versions, so that the user does not have to delete it.
|
|
version="1.7.5.212"
|
|
|
|
} |