daily pastebin goal
1%
SHARE
TWEET

OpenComputers config

hobbyboy Dec 20th, 2013 1,746 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. # OpenComputers configuration. This file uses typesafe config's HOCON syntax.
  2. # Try setting your syntax highlighting to YAML, to help readability. At least
  3. # in Sublime Text that works really well.
  4. # Note that this file is only written if it doesn't exist or is empty. This
  5. # means that if new settings are added to mod, they will *not* appear in an
  6. # already existing config file! Sorry about the inconvenience.
  7. opencomputers {
  8.  
  9.   # Computer related settings, concerns server performance and security.
  10.   computer {
  11.  
  12.     # Sanity check for username length for users registered with computers. We
  13.     # store the actual user names instead of a hash to allow iterating the
  14.     # list of registered users on the Lua side.
  15.     # See also: `canComputersBeOwned`.
  16.     maxUsernameLength=32
  17.  
  18.     # The maximum number of users that can be registered with a single
  19.     # computer. This is used to avoid computers allocating unchecked amounts
  20.     # of memory by registering an unlimited number of users. See also:
  21.     # `canComputersBeOwned`.
  22.     maxUsers=16
  23.  
  24.     # This determines whether computers can only be used by players that are
  25.     # registered as users on them. Per default a newly placed computer has no
  26.     # users. Whenever there are no users the computer is free for all. Users
  27.     # can be managed via the Lua API (computer.addUser, computer.removeUser,
  28.     # computer.users). If this is true, the following interactions are only
  29.     # possible for users:
  30.     # - input via the keyboard and touch screen.
  31.     # - inventory management.
  32.     # - breaking the computer block.
  33.     # If this is set to false, all computers will always be usable by all
  34.     # players, no matter the contents of the user list. Note that operators
  35.     # are treated as if they were in the user list of every computer, i.e. no
  36.     # restrictions apply to them.
  37.     # See also: `maxUsers` and `maxUsernameLength`.
  38.     canComputersBeOwned=true
  39.  
  40.     # The overall number of threads to use to drive computers. Whenever a
  41.     # computer should run, for example because a signal should be processed or
  42.     # some sleep timer expired it is queued for execution by a worker thread.
  43.     # The higher the number of worker threads, the less likely it will be that
  44.     # computers block each other from running, but the higher the host
  45.     # system's load may become.
  46.     threads=4
  47.  
  48.     # This setting allows you to fine-tune how RAM sizes are scaled internally
  49.     # on 64 Bit machines (i.e. when the Minecraft server runs in a 64 Bit VM).
  50.     # Why is this even necessary? Because objects consume more memory in a 64
  51.     # Bit environment than in a 32 Bit one, due to pointers and possibly some
  52.     # integer types being twice as large. It's actually impossible to break
  53.     # this down to a single number, so this is really just a rough guess. If
  54.     # you notice this doesn't match what some Lua program would use on 32 bit,
  55.     # feel free to play with this and report your findings!
  56.     # Note that the values *displayed* to Lua via `computer.totalMemory` and
  57.     # `computer.freeMemory` will be scaled by the inverse, so that they always
  58.     # correspond to the "apparent" sizes of the installed memory modules. For
  59.     # example, when running a computer with a 64KB RAM module, even if it's
  60.     # scaled up to 96KB, `computer.totalMemory` will return 64KB, and if there
  61.     # are really 45KB free, `computer.freeMemory` will return 32KB.
  62.     ramScaleFor64Bit=1.8
  63.  
  64.     # The time in seconds to wait after a computer has been restored before it
  65.     # continues to run. This is meant to allow the world around the computer
  66.     # to settle, avoiding issues such as components in neighboring chunks
  67.     # being removed and then re-connected and other odd things that might
  68.     # happen.
  69.     startupDelay=0.25
  70.  
  71.     # The sizes of the three tiers of RAM, in kilobytes. This list must
  72.     # contain exactly three entries, or it will be ignored.
  73.     ramSizes=[
  74.       64,
  75.       128,
  76.       256
  77.     ]
  78.  
  79.     # Whether to actively run Lua's garbage collector each time before the
  80.     # Lua state of a computer is resumed. This has two advantages: memory is
  81.     # less likely to run out because the emergency gargabe collection fails
  82.     # to release certain structures, and Lua programs will get a better idea
  83.     # of how much ram is *really* still available (otherwise the numbers you
  84.     # get from os.freeMemory() will jump - a lot). The downside is that this
  85.     # obviously is slightly more computationally expensive. However, since
  86.     # the memory sizes for Lua states will generally be very small, due to
  87.     # limited amount reachable via RAM items (per default 2*256KB) and being
  88.     # run in a low-priority worker thread, this should be barely noticeable.
  89.     activeGC=true
  90.  
  91.     # The time in seconds a program may run without yielding before it is
  92.     # forcibly aborted. This is used to avoid stupidly written or malicious
  93.     # programs blocking other computers by locking down the executor threads.
  94.     # Note that changing this won't have any effect on computers that are
  95.     # already running - they'll have to be rebooted for this to take effect.
  96.     timeout=1
  97.   }
  98.  
  99.   # Client side settings, presentation and performance related stuff.
  100.   client {
  101.  
  102.     # Whether to apply linear filtering for text displayed on screens when the
  103.     # screen has to be scaled down - i.e. the text is rendered at a resolution
  104.     # lower than their native one, e.g. when the GUI scale is less than one or
  105.     # when looking at a far away screen. This leads to smoother text for
  106.     # scaled down text but results in characters not perfectly connecting
  107.     # anymore (for example for box drawing characters. Look it up on
  108.     # Wikipedia.)
  109.     textLinearFiltering=false
  110.  
  111.     # The distance at which to start fading out the text on screens. This is
  112.     # purely cosmetic, to avoid text disappearing instantly when moving too
  113.     # far away from a screen. This should have no measurable impact on
  114.     # performance. Note that this needs OpenGL 1.4 to work, otherwise text
  115.     # will always just instantly disappear when moving away from the screen
  116.     # displaying it.
  117.     screenTextFadeStartDistance=8
  118.  
  119.     # The maximum distance at which to render text on screens. Rendering text
  120.     # can be pretty expensive, so if you have a lot of screens you'll want to
  121.     # avoid huge numbers here. Note that this setting is client-sided, and
  122.     # only has an impact on render performance on clients.
  123.     maxScreenTextRenderDistance=10
  124.   }
  125.  
  126.   # HTTP settings, security related.
  127.   http {
  128.  
  129.     # The number of threads used for processing HTTP requests in the
  130.     # background. The more there are, the more concurrent connections can
  131.     # potentially be opened by computers, and the less likely they are to
  132.     # delay each other.
  133.     threads=4
  134.  
  135.     # This is a list of blacklisted domain names. If an HTTP request is made
  136.     # and the host name (domain) of the target URL matches any of the patterns
  137.     # in this list, the request will be denied.
  138.     # All entries are regular expression patterns, but they will only be
  139.     # applied to the host name (domain) of a given URL.
  140.     blacklist=[
  141.       "^127\\.0\\.0\\.1$",
  142.       "^10\\.\\d+\\.\\d+\\.\\d+$",
  143.       "^192\\.\\d+\\.\\d+\\.\\d+$"
  144.     ]
  145.  
  146.     # Whether to allow HTTP requests via wireless network cards. When enabled,
  147.     # pass a URL to `send`, to perform an HTTP request. The second parameter
  148.     # becomes an optional string to send as POST data. When the request
  149.     # finishes, it will push a signal named `http_response`. If the request
  150.     # cannot be performed because the URL is not allowed or this is disabled
  151.     # the card will fall back to the normal send logic.
  152.     enable=true
  153.  
  154.     # This is a list of whitelisted domain names. Requests may only be made to
  155.     # domains that match any pattern in this list. If this list is empty,
  156.     # requests may be made to all domains not blacklisted. Note that the
  157.     # blacklist is always applied, so if an entry is present in both the
  158.     # whitelist and the blacklist, the blacklist will win.
  159.     # All entries are regular expression patterns, but they will only be
  160.     # applied to the host name (domain) of a given URL.
  161.     whitelist=[
  162.       "^gist\\.github\\.com$",
  163.       "^(:?www\\.)?pastebin\\.com$"
  164.     ]
  165.   }
  166.   ids {
  167.  
  168.     # The item ID used for all non-damageable items.
  169.     item=4600
  170.  
  171.     # List of block IDs the mod uses for different types of blocks. This list
  172.     # must contain exactly four entries, or it will be ignored.
  173.     block=[
  174.       3650,
  175.       3651,
  176.       3652,
  177.       3653
  178.     ]
  179.   }
  180.  
  181.   # Power settings, buffer sizes and power consumption.
  182.   power {
  183.     buffer {
  184.  
  185.       # The amount of power a computer can store. This allows you to get a
  186.       # computer up and running without also having to build a capacitor.
  187.       computer=500
  188.  
  189.       # The amount of energy a single capacitor can store.
  190.       capacitor=1600
  191.  
  192.       # The amount of power a converter can store. This allows directly
  193.       # connecting a converter to a distributor, without having to have a
  194.       # capacitor on the side of the converter.
  195.       converter=1000
  196.  
  197.       # The amount of bonus energy a capacitor can store for each other
  198.       # capacitor it shares a face with. This bonus applies to both of the
  199.       # involved capacitors. It reaches a total of two blocks, where the
  200.       # bonus is halved for the second neighbor. So three capacitors in a
  201.       # row will give a total of 8.8k storage with default values:
  202.       # (1.6 + 0.8 + 0.4)k + (0.8 + 1.6 + 0.8)k + (0.4 + 0.8 + 1.6)k
  203.       capacitorAdjacencyBonus=800
  204.  
  205.       # The amount of power robots can store in their internal buffer.
  206.       robot=50000
  207.     }
  208.  
  209.     # The amount of energy a Charger transfers to each adjacent robot per tick
  210.     # if a maximum strength redstone signal is set. Chargers load robots with
  211.     # a controllable speed, based on the maximum strength of redstone signals
  212.     # going into the block. So if a redstone signal of eight is set, it'll
  213.     # charge robots at roughly half speed.
  214.     chargerChargeRate=100
  215.  
  216.     # Conversion ratio for Thermal Expansion's RF. This is how many internal
  217.     # energy units one RF generates.
  218.     ratioThermalExpansion=0.1
  219.  
  220.     # Whether to ignore any power requirements. Whenever something requires
  221.     # power to function, it will try to get the amount of energy it needs from
  222.     # the buffer of its connector node, and in case it fails it won't perform
  223.     # the action / trigger a shutdown / whatever. Setting this to `true` will
  224.     # simply make the check 'is there enough energy' succeed unconditionally.
  225.     # Note that buffers are still filled and emptied following the usual
  226.     # rules, there just is no failure case anymore. The converter will however
  227.     # not accept power from other mods.
  228.     ignorePower=false
  229.  
  230.     # This determines how often continuous power sinks try to actually try to
  231.     # consume energy from the network. This includes computers, robots and
  232.     # screens. This also controls how frequent distributors revalidate their
  233.     # global state and secondary distributors, as well as how often the power
  234.     # converter queries sources for energy (for now: only BuildCraft). If set
  235.     # to 1, this would query every tick. The default queries every 20 ticks,
  236.     # or in other words once per second.
  237.     # Higher values mean more responsive power consumption, but slightly more
  238.     # work per tick (shouldn't be that noticeable, though). Note that this
  239.     # has no influence on the actual amount of energy required by computers
  240.     # and screens. The power cost is directly scaled up accordingly:
  241.     # `tickFrequency * cost`.
  242.     tickFrequency=20
  243.  
  244.     # Conversion ratio for BuildCraft's MJ. This is how many internal energy
  245.     # units one MJ generates.
  246.     ratioBuildCraft=1
  247.  
  248.     # Conversion ratio for IndustrialCraft2's EU. This is how many internal
  249.     # energy units one EU generates.
  250.     ratioIndustrialCraft2=0.4
  251.  
  252.     # The energy efficiency of the generator upgrade. At 1.0 this will
  253.     # generate as much energy as you'd get by burning the fuel in a BuildCraft
  254.     # Stirling Engine (1MJ per fuel value / burn ticks). To discourage fully
  255.     # autonomous robots the efficiency of generators is slighly reduced by
  256.     # default.
  257.     generatorEfficiency=0.8
  258.  
  259.     # Conversion ratio for Universal Electricity's Joules. This is how many
  260.     # internal energy units one Joule generates.
  261.     ratioUniversalElectricity=1
  262.     cost {
  263.  
  264.       # The amount of energy a computer consumes per tick when running.
  265.       computer=0.5
  266.  
  267.       # The amount of energy a screen consumes per displayed character per
  268.       # tick. If a screen cannot consume the defined amount of energy it
  269.       # will stop rendering the text that should be displayed on it. It will
  270.       # *not* forget that text, however, so when enough power is available
  271.       # again it will restore the previously displayed text (with any
  272.       # changes possibly made in the meantime). Note that for multi-block
  273.       # screens *each* screen that is part of it will consume this amount of
  274.       # energy per tick.
  275.       screen=0.1
  276.  
  277.       # Energy it takes to change *every* 'pixel' via the set command of a
  278.       # basic screen via the `set` command.
  279.       # Note: internally this is adjusted to a cost per pixel, and applied
  280.       # as such, so this also implicitly defines the cost for higher tier
  281.       # screens.
  282.       gpuSet=2
  283.  
  284.       # Energy it takes to clear a basic screen using the fill command with
  285.       # 'space' as the fill char.
  286.       # Note: internally this is adjusted to a cost per pixel, and applied
  287.       # as such, so this also implicitly defines the cost for higher tier
  288.       # screens.
  289.       gpuClear=0.25
  290.  
  291.       # The amount of energy a robot consumes per tick when running. This is
  292.       # per default less than a normal computer uses because... well... they
  293.       # are better optimized? It balances out due to the cost for movement,
  294.       # interaction and whatnot, and the fact that robots cannot connect to
  295.       # component networks directly, so they are no replacements for normal
  296.       # computers.
  297.       robot=0.25
  298.  
  299.       # The amount of energy it costs to send a signal with strength one,
  300.       # which means the signal reaches one block. This is scaled up
  301.       # linearly, so for example to send a signal 400 blocks a signal
  302.       # strength of 400 is required, costing a total of 400 *
  303.       # `wirelessCostPerRange`. In other words, the higher this value, the
  304.       # higher the cost of wireless messages.
  305.       # See also: `maxWirelessRange`.
  306.       wirelessStrength=0.05
  307.  
  308.       # The actual cost per tick for computers and robots is multiplied
  309.       # with this value if they are currently in a "sleeping" state. They
  310.       # enter this state either by calling `os.sleep()` or by pulling
  311.       # signals. Note that this does not apply in the tick they resume, so
  312.       # you can't fake sleep by calling `os.sleep(0)`.
  313.       sleepFactor=0.1
  314.  
  315.       # The amount of energy it takes a robot to perform a 90 degree turn.
  316.       robotTurn=2.5
  317.  
  318.       # The conversion rate of exhaustion from using items to energy
  319.       # consumed. Zero means exhaustion does not require energy, one is a
  320.       # one to one conversion. For example, breaking a block generates 0.025
  321.       # exhaustion, attacking an entity generates 0.3 exhaustion.
  322.       robotExhaustion=10
  323.  
  324.       # The amount of energy it takes a robot to move a single block.
  325.       robotMove=15
  326.  
  327.       # Energy it takes to write one kilobyte to a file system.
  328.       # Note: internally this is adjusted to a cost per byte, and applied
  329.       # as such. It's just specified per kilobyte to be more intuitive.
  330.       hddWrite=0.25
  331.  
  332.       # Energy it takes to change a basic screen with the fill command.
  333.       # Note: internally this is adjusted to a cost per pixel, and applied
  334.       # as such, so this also implicitly defines the cost for higher tier
  335.       # screens.
  336.       gpuFill=1.5
  337.  
  338.       # Energy it takes read one kilobyte from a file system. Note that non
  339.       # I/O operations on file systems such as `list` or `getFreeSpace` do
  340.       # *not* consume power. Note that this very much determines how much
  341.       # energy you need in store to start a computer, since you need enough
  342.       # to have the computer read all the libraries, which is around 60KB
  343.       # at the time of writing.
  344.       # Note: internally this is adjusted to a cost per byte, and applied
  345.       # as such. It's just specified per kilobyte to be more intuitive.
  346.       hddRead=0.1
  347.  
  348.       # Energy it takes to copy half of a basic screen via the copy command.
  349.       # Note: internally this is adjusted to a cost per pixel, and applied
  350.       # as such, so this also implicitly defines the cost for higher tier
  351.       # screens.
  352.       gpuCopy=0.5
  353.     }
  354.   }
  355.  
  356.   # Robot related settings, what they may do and general balancing.
  357.   robot {
  358.  
  359.     # Whether robots may use items for a specifiable duration. This allows
  360.     # robots to use items such as bows, for which the right mouse button has
  361.     # to be held down for a longer period of time. For robots this works
  362.     # slightly different: the item is told it was used for the specified
  363.     # duration immediately, but the robot will not resume execution until the
  364.     # time that the item was supposedly being used has elapsed. This way
  365.     # robots cannot rapidly fire critical shots with a bow, for example.
  366.     allowUseItemsWithDuration=true
  367.  
  368.     # Whether robots may place blocks in thin air, i.e. without a reference
  369.     # point (as is required for real players). Set this to true to emulate
  370.     # ComputerCraft's Turtles' behavior. When left false robots have to target
  371.     # an existing block face to place another block. Note that calling either
  372.     # `robot.place` or `robot.use` without a side will cause the robot to try
  373.     # all valid sides.
  374.     canPlaceInAir=false
  375.     delays {
  376.  
  377.       # The time in seconds to pause execution after a robot turned either
  378.       # left or right. Note that this essentially determines hw fast robots
  379.       # can turn around, since this also determines the length of the turn
  380.       # animation.
  381.       turn=0.4
  382.  
  383.       # This is the *ratio* of the time a player would require to harvest a
  384.       # block. Note that robots cannot break blocks they cannot harvest. So
  385.       # the time a robot is forced to sleep after harvesting a block is
  386.       #   breakTime * harvestRatio
  387.       # Breaking a block will always at least take one tick, 0.05 seconds.
  388.       harvestRatio=1
  389.  
  390.       # The time in seconds to pause execution after an item was
  391.       # successfully dropped from a robot's inventory.
  392.       drop=0.5
  393.  
  394.       # The time in seconds to pause execution after a robot successfully
  395.       # picked up an item after triggering a suck command.
  396.       suck=0.5
  397.  
  398.       # The time in seconds to pause execution after a robot successfully
  399.       # used an equipped tool (or it's 'hands' if nothing is equipped).
  400.       # Successful in this case means that it either used the equipped item,
  401.       # for example a splash potion, or that it activated a block, for
  402.       # example by pushing a button.
  403.       # Note that if an item is used for a specific amount of time, like
  404.       # when shooting a bow, the maximum of this and the duration of the
  405.       # item use is taken.
  406.       use=0.4
  407.  
  408.       # The time in seconds to pause execution after a robot successfully
  409.       # placed an item from its inventory.
  410.       place=0.4
  411.  
  412.       # The time in seconds to pause execution after a robot successfully
  413.       # swung a tool (or it's 'hands' if nothing is equipped). Successful in
  414.       # this case means that it hit something, i.e. it attacked an entity or
  415.       # extinguishing fires.
  416.       # When breaking blocks the normal harvest time scaled with the
  417.       # `harvestRatio` (see below) applies.
  418.       swing=0.4
  419.  
  420.       # The time in seconds to pause execution after a robot issued a
  421.       # successful move command. Note that this essentially determines how
  422.       # fast robots can move around, since this also determines the length
  423.       # of the move animation.
  424.       move=0.4
  425.     }
  426.  
  427.     # The rate at which items used as tools by robots take damage. A value of
  428.     # one means that items lose durability as quickly as when they are used by
  429.     # a real player. A value of zero means they will not lose any durability
  430.     # at all. This only applies to items that can actually be damaged (such as
  431.     # swords, pickaxes, axes and shovels).
  432.     # Note that this actually is the *chance* of an item losing durability
  433.     # when it is used. Or in other words, it's the inverse chance that the
  434.     # item will be automatically repaired for the damage it just took
  435.     # immediately after it was used.
  436.     itemDamageRate=0.1
  437.  
  438.     # This controls how fast robots gain experience, and how that experience
  439.     # alters the stats.
  440.     xp {
  441.       constantGrowth=3
  442.  
  443.       # This controls how much experience a robot gains for each successful
  444.       # action it performs. "Actions" only include the following: swinging a
  445.       # tool and killing something or destroying a block and placing a block
  446.       # successfully. Note that a call to `swing` or `use` while "bare handed"
  447.       # will *not* gain a robot any experience.
  448.       actionXp=0.05
  449.  
  450.       # The increase in block harvest speed a robot gains per level. The time
  451.       # it takes to break a block is computed as actualTime * (1 - bonus).
  452.       # For example at level 20, with a bonus of 0.4 instead of taking 0.3
  453.       # seconds to break a stone block with a diamond pick axe it only takes
  454.       # 0.12 seconds.
  455.       harvestSpeedBoostPerLevel=0.02
  456.       exponentialGrowth=3
  457.  
  458.       # This determines how much "exhaustion" contributes to a robots
  459.       # experience. This is additive to the "action" xp, so digging a block
  460.       # will per default give 0.05 + 0.025 [exhaustion] * 1.0 = 0.075 XP.
  461.       exhaustionXpRate=1
  462.  
  463.       # This is the amount of additional energy that fits into a robots
  464.       # internal buffer for each level it gains. So with the default values,
  465.       # at maximum level (30) a robot will have an internal buffer size of
  466.       # two hundred thousand.
  467.       bufferPerLevel=5000
  468.  
  469.       # The additional "efficiency" a robot gains in using tools with each
  470.       # level. This basically increases the chances of a tool not losing
  471.       # durability when used, relative to the base rate. So for example, a
  472.       # robot with level 15 gets a 0.15 bonus, with the default damage rate
  473.       # that would lead to a damage rate of 0.1 * (1 - 0.15) = 0.085.
  474.       toolEfficiencyPerLevel=0.01
  475.  
  476.       # The required amount per level is computed like this:
  477.       # xp(level) = baseValue + (level * constantGrowth) ^ exponentialGrowth
  478.       baseValue=50
  479.     }
  480.  
  481.     # Determines whether robots are a pretty cool guy. Ususally cobwebs are
  482.     # the bane of anything using a tool other than a sword or shears. This is
  483.     # an utter pain in the part you sit on, because it makes robots meant to
  484.     # dig holes utterly useless: the poor things couldn't break cobwebs in
  485.     # mining shafts with their golden pick axes. So, if this setting is true,
  486.     # we check for cobwebs and allow robots to break 'em anyway, no matter
  487.     # their current tool. After all, the hardness value of cobweb can only
  488.     # rationally explained by Steve's fear of spiders, anyway.
  489.     notAfraidOfSpiders=true
  490.  
  491.     # The name format to use for robots. The substring '$player$' is
  492.     # replaced with the name of the player that owns the robot, so for the
  493.     # first robot placed this will be the name of the player that placed it.
  494.     # This is transitive, i.e. when a robot in turn places a robot, that
  495.     # robot's owner, too, will be the owner of the placing robot.
  496.     # The substring $random$ will be replaced with a random number in the
  497.     # interval [1, 0xFFFFFF], which may be useful if you need to differentiate
  498.     # individual robots.
  499.     # If a robot is placed by something that is not a player, e.g. by some
  500.     # block from another mod, the name will default to 'OpenComputers'.
  501.     nameFormat="$player$.robot"
  502.  
  503.     # Whether robots may damage players if they get in their way. This
  504.     # includes all 'player' entities, which may be more than just real players
  505.     # in the game.
  506.     canAttackPlayers=false
  507.  
  508.     # The 'range' of robots when using an equipped tool (right click) or when
  509.     # placing items from their inventory. See `robot.swingRange`. This
  510.     # defaults to a value large enough to allow robots to detect 'farmland',
  511.     # i.e. tilled dirt, so that they can plant seeds.
  512.     useAndPlaceRange=0.65
  513.  
  514.     # The 'range' of robots when swinging an equipped tool (left click). This
  515.     # is the distance to the center of block the robot swings the tool in to
  516.     # the side the tool is swung towards. I.e. for the collision check, which
  517.     # is performed via ray tracing, this determines the end point of the ray
  518.     # like so: `block_center + unit_vector_towards_side * swingRange`
  519.     # This defaults to a value just below 0.5 to ensure the robots will not
  520.     # hit anything that's actually outside said block.
  521.     swingRange=0.49
  522.  
  523.     # Whether robots may 'activate' blocks in the world. This includes
  524.     # pressing buttons and flipping levers, for example. Disable this if it
  525.     # causes problems with some mod (but let me know!) or if you think this
  526.     # feature is too over-powered.
  527.     allowActivateBlocks=true
  528.   }
  529.  
  530.   # File system related settings, performance and and balancing.
  531.   filesystem {
  532.  
  533.     # Whether persistent file systems such as disk drivers should be
  534.     # 'buffered', and only written to disk when the world is saved. This
  535.     # applies to all hard drives. The advantage of having this enabled is that
  536.     # data will never go 'out of sync' with the computer's state if the game
  537.     # crashes. The price is slightly higher memory consumption, since all
  538.     # loaded files have to be kept in memory (loaded as in when the hard drive
  539.     # is in a computer).
  540.     bufferChanges=true
  541.  
  542.     # The sizes of the three tiers of hard drives, in kilobytes. This list
  543.     # must contain exactly three entries, or it will be ignored.
  544.     hddSizes=[
  545.       1024,
  546.       2048,
  547.       4096
  548.     ]
  549.  
  550.     # The maximum number of file handles any single computer may have open at
  551.     # a time. Note that this is *per filesystem*. Also note that this is only
  552.     # enforced by the filesystem node - if an add-on decides to be fancy it
  553.     # may well ignore this. Since file systems are usually 'virtual' this will
  554.     # usually not have any real impact on performance and won't be noticeable
  555.     # on the host operating system.
  556.     maxHandles=16
  557.  
  558.     # The maximum block size that can be read in one 'read' call on a file
  559.     # system. This is used to limit the amount of memory a call from a user
  560.     # program can cause to be allocated on the host side: when 'read' is,
  561.     # called a byte array with the specified size has to be allocated. So if
  562.     # this weren't limited, a Lua program could trigger massive memory
  563.     # allocations regardless of the amount of RAM installed in the computer it
  564.     # runs on. As a side effect this pretty much determines the read
  565.     # performance of file systems.
  566.     maxReadBuffer=8192
  567.  
  568.     # The size of the /tmp filesystem that each computer gets for free. If
  569.     # set to a non-positive value the tmp file system will not be created.
  570.     tmpSize=64
  571.  
  572.     # The base 'cost' of a single file or directory on a limited file system,
  573.     # such as hard drives. When computing the used space we add this cost to
  574.     # the real size of each file (and folders, which are zero sized
  575.     # otherwise). This is to ensure that users cannot spam the file system
  576.     # with an infinite number of files and/or folders. Note that the size
  577.     # returned via the API will always be the real file size, however.
  578.     fileCost=512
  579.  
  580.     # The size of writable floppy disks, in kilobytes.
  581.     floppySize=512
  582.   }
  583.  
  584.   # Other settings that you might find useful to tweak.
  585.   misc {
  586.  
  587.     # The maximum height of multi-block screens, in blocks. This is limited to
  588.     # avoid excessive computations for merging screens. If you really need
  589.     # bigger screens it's probably safe to bump this quite a bit before you
  590.     # notice anything, since at least incremental updates should be very
  591.     # efficient (i.e. when adding/removing a single screen).
  592.     maxScreenHeight=6
  593.  
  594.     # The maximum distance a wireless message can be sent. In other words,
  595.     # this is the maximum signal strength a wireless network card supports.
  596.     # This is used to limit the search range in which to check for modems,
  597.     # which may or may not lead to performance issues for ridiculous ranges -
  598.     # like, you know, more than the loaded area.
  599.     # See also: `wirelessCostPerRange`.
  600.     maxWirelessRange=400
  601.  
  602.     # The maximum width of multi-block screens, in blocks.
  603.     # See also: `maxScreenHeight`.
  604.     maxScreenWidth=8
  605.  
  606.     # The maximum length of a string that may be pasted. This is used to limit
  607.     # the size of the data sent to the server when the user tries to paste a
  608.     # string from the clipboard (Shift+Ins on a screen with a keyboard).
  609.     maxClipboard=1024
  610.  
  611.     # The user name to specify when executing a command via a command block.
  612.     # If you leave this empty it will use the address of the network node that
  613.     # sent the execution request - which will usually be a computer.
  614.     commandUser=OpenComputers
  615.  
  616.     # The maximum size of network packets to allow sending via network cards.
  617.     # This has *nothing to do* with real network traffic, it's just a limit
  618.     # for the network cards, mostly to reduce the chance of computer with a
  619.     # lot of RAM killing those with less by sending huge packets. This does
  620.     # not apply to HTTP traffic.
  621.     maxNetworkPacketSize=8192
  622.   }
  623.  
  624. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top