| # 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 { |
| # 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: "@VERSION@" |
| |
| # Client side settings, presentation and performance related stuff. |
| client { |
| # 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.0 |
| |
| # 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.0 |
| |
| # 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 |
| |
| # If you prefer the text on the screens to be aliased (you know, *not* |
| # anti-aliased / smoothed) turn this option off. |
| textAntiAlias: true |
| |
| # Render robots' names as a label above them when near them |
| robotLabels: true |
| |
| # The volume multiplier applied to sounds from this mod like the computer |
| # running noise. Disable sounds by setting this to zero. |
| soundVolume: 1.0 |
| |
| # 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 |
| |
| # 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 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 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 |
| |
| # Which font renderer to use. Defaults to `unifont` if invalid. |
| # Possible values: |
| # - unifont: the (since 1.3.2) default font renderer. Based on the |
| # Unifont and 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: "unifont" |
| |
| # 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 |
| |
| # The radius in which computer beeps can be heard. |
| beepRadius: 16 |
| |
| # 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] |
| |
| # 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 |
| } |
| |
| # Computer related settings, concerns server performance and security. |
| computer { |
| # 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.0 |
| |
| # 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 maximum size of the byte array that can be stored on EEPROMs as executable data.. |
| eepromSize: 4096 |
| |
| # The maximum size of the byte array that can be stored on EEPROMs as configuration data. |
| eepromDataSize: 256 |
| |
| # The number of components the different CPU tiers support. This list |
| # must contain exactly three entries, or it will be ignored. |
| cpuComponentCount: [ |
| 8 |
| 12 |
| 16 |
| ] |
| |
| # 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.0 |
| 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 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 |
| |
| # 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 |
| |
| # 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 available. If enabled, you |
| # can reconfigure any CPU to use the Lua 5.3 architecture. |
| enableLua53: true |
| |
| # 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 |
| ] |
| |
| # 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 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 |
| } |
| } |
| |
| # 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 |
| |
| # 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 maximum flight height with upgrades, tier one and tier two of the |
| # hover upgrade, respectively. |
| upgradeFlightHeight: [64, 256] |
| |
| # 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 '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 |
| |
| # 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 |
| |
| # 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" |
| |
| # 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 { |
| # The required amount per level is computed like this: |
| # xp(level) = baseValue + (level * constantGrowth) ^ exponentialGrowth |
| baseValue: 50 |
| |
| # The required amount per level is computed like this: |
| # xp(level) = baseValue + (level * constantGrowth) ^ exponentialGrowth |
| constantGrowth: 8 |
| |
| # The required amount per level is computed like this: |
| # xp(level) = baseValue + (level * constantGrowth) ^ exponentialGrowth |
| exponentialGrowth: 2 |
| |
| # 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 |
| |
| # 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.0 |
| |
| # 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.0 |
| |
| # 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 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 |
| |
| # 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 |
| } |
| |
| # Allows fine-tuning of delays for robot actions. |
| delays { |
| # 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 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 |
| # 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 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 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 an item was |
| # successfully dropped from a robot's inventory. |
| drop: 0.5 |
| |
| # The time in seconds to pause execution after a robot successfully |
| # picked up an item after triggering a suck command. |
| suck: 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.0 |
| } |
| } |
| |
| # Power settings, buffer sizes and power consumption. |
| power { |
| # 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 |
| |
| # 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 |
| |
| # 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.0 |
| |
| # 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.0 |
| |
| # 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 |
| |
| # 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 |
| |
| # The amount of energy the robot assembler can apply per tick. This |
| # controls the speed at which robots are assembled, basically. |
| assemblerTickAmount: 50 |
| |
| # The amount of energy the disassembler can apply per tick. This |
| # controls the speed at which items are disassembled, basically. |
| disassemblerTickAmount: 25 |
| |
| # The amount of energy the printer can apply per tick. This controls |
| # the speed at which prints are completed, basically. |
| printerTickAmount: 1 |
| |
| # 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: [] |
| |
| # Default "buffer" sizes, i.e. how much energy certain blocks can store. |
| buffer { |
| # The amount of energy a single capacitor can store. |
| capacitor: 1600.0 |
| |
| # 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.0 |
| |
| # 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 computer can store. This allows you to get a |
| # computer up and running without also having to build a capacitor. |
| computer: 500.0 |
| |
| # The amount of energy a microcontroller can store in its internal |
| # buffer. |
| mcu: 1000.0 |
| |
| # The amount a tablet can store in its internal buffer. |
| tablet: 10000 |
| |
| # The amount of energy robots can store in their internal buffer. |
| robot: 20000.0 |
| |
| # The amount of energy a drone can store in its internal buffer. |
| drone: 5000.0 |
| |
| # 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.0 |
| |
| # The amount of energy each face of a distributor can story. 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 an access point can store. |
| accessPoint: 600.0 |
| |
| # The internal buffer size of the hover boots. |
| hoverBoots: 15000.0 |
| |
| # Amount of energy stored by nanomachines. Yeah, I also don't know |
| # where all that energy is stored. It's quite fascinating. |
| nanomachines: 100000 |
| } |
| |
| # Default "costs", i.e. how much energy certain operations consume. |
| cost { |
| # The amount of energy a computer consumes per tick when running. |
| computer: 0.5 |
| |
| # Amount of energy a microcontroller consumes per tick while running. |
| microcontroller: 0.1 |
| |
| # 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 amount of energy a drone consumes per tick when running. |
| drone: 0.4 |
| |
| # 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 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 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 |
| |
| # 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 |
| |
| # 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.0 |
| |
| # 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.0 |
| |
| # 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 |
| |
| # The amount of energy it takes a robot to perform a 90 degree turn. |
| robotTurn: 2.5 |
| |
| # The amount of energy it takes a robot to move a single block. |
| robotMove: 15.0 |
| |
| # 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.0 |
| |
| # 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`. |
| wirelessCostPerRange: 0.05 |
| |
| # The cost of a single packet sent via StargateTech 2's abstract bus. |
| abstractBusPacket: 1 |
| |
| # How much energy is consumed when the Geolyzer scans a block. |
| geolyzerScan: 10 |
| |
| # 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 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 |
| |
| # 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 |
| |
| # 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 |
| |
| # 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 the chunkloader upgrade draws per tick while |
| # it is enabled, i.e. actually loading a chunk. |
| chunkloaderCost: 0.06 |
| |
| # The amount of energy pushing blocks with the piston upgrade costs. |
| pistonPush: 20 |
| |
| # 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 required for a single 3D print. |
| printerModel: 100 |
| |
| # 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 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 *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 |
| |
| # 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 |
| |
| # Cost for simple operations on the data card, such as MD5 or AES |
| dataCardSimple: 1.0 |
| |
| # Per-byte cost for simple operations |
| dataCardSimpleByte: 0.01 |
| |
| # Cost for complex operations on the data card, such as SHA256, inflate/deflate and SecureRandom. |
| dataCardComplex: 6.0 |
| |
| # Per-byte cost for complex operations |
| dataCardComplexByte: 0.1 |
| |
| # 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.0 |
| |
| # Energy required for one transposer operation (regardless of the number |
| # of items / fluid volume moved). |
| transposer: 1 |
| |
| # Energy consumed per tick per active input node by nanomachines. |
| nanomachineInput: 0.5 |
| |
| # Energy consumed when reconfiguring nanomachines. |
| nanomachinesReconfigure: 5000 |
| } |
| |
| # The rate at which different blocks accept external power. All of these |
| # values are in OC energy / tick. |
| rate { |
| accessPoint: 10.0 |
| assembler: 100.0 |
| case: [ |
| 5.0 |
| 10.0 |
| 20.0 |
| ] |
| charger: 200.0 |
| disassembler: 50.0 |
| powerConverter: 500.0 |
| serverRack: 50.0 |
| } |
| |
| # 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.0 |
| Factorization: 13.0 |
| Galacticraft: 48.0 |
| IndustrialCraft2: 400.0 |
| Mekanism: 1333.33 |
| RedstoneFlux: 100.0 |
| RotaryCraft: 200.0 # / 11256, same as AE2 |
| } |
| } |
| |
| # File system related settings, performance and and balancing. |
| filesystem { |
| # Whether persistent file systems such as disk drivers 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 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 size of writable floppy disks, in kilobytes. |
| floppySize: 512 |
| |
| # 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 |
| |
| # 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 |
| |
| # 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, 6 ] |
| |
| # 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 |
| } |
| |
| # Internet settings, security related. |
| internet { |
| # 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 |
| |
| # 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 / adress 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" |
| ] |
| |
| # 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: [] |
| |
| # 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 maximum concurrent TCP connections *each* internet card can have |
| # open at a time. |
| maxTcpConnections: 4 |
| |
| # 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 |
| } |
| |
| # Switch and access point network message forwarding logic related stuff. |
| switch { |
| # 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 |
| |
| # The amount of ticks the delay is *reduced* by per tier of the CPU |
| # inserted into a switch. |
| relayDelayUpgrade: 1.5 |
| |
| # 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 |
| |
| # This is the amount by which the queue size increases per tier of the |
| # hard drive installed in the switch. |
| queueSizeUpgrade: 10 |
| |
| # The base number of packets that get relayed in one 'cycle'. The |
| # cooldown between cycles is determined by the delay. |
| defaultRelayAmount: 1 |
| |
| # 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 |
| } |
| |
| # 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 { |
| # 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 |
| |
| # The relative number of connectors based on the number of available |
| # behaviors (see triggerQuota). |
| connectorQuota: 0.2 |
| |
| # 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 |
| |
| # The maximum number of outputs for each node (see maxInputs). |
| maxOutputs: 2 |
| |
| # How many input nodes may be active at the same time before negative |
| # effects are applied to the player. |
| safeInputsActive: 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 |
| |
| # 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 |
| |
| # Range of the item magnet behavior added for each active input. |
| magnetRange: 8 |
| |
| # Radius in blocks of the disintegration behavior for each active input. |
| disintegrationRange: 1 |
| |
| # 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: [ |
| "potion.moveSpeed", |
| "potion.digSpeed", |
| "potion.damageBoost", |
| "potion.jump", |
| "potion.resistance", |
| "potion.fireResistance", |
| "potion.waterBreathing", |
| "potion.nightVision", |
| "potion.absorption", |
| |
| "potion.blindness", |
| "potion.confusion", |
| "potion.digSlowDown", |
| "potion.harm", |
| "potion.hunger", |
| "potion.moveSlowdown", |
| "potion.poison", |
| "potion.weakness", |
| "potion.wither" |
| ] |
| |
| # 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 |
| } |
| |
| # 3D printer related stuff. |
| printer { |
| # 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 |
| |
| # 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 |
| |
| # Whether Chamelium is edible or not. When eaten, it gives a (short) |
| # invisibility buff, and (slightly longer) blindness debuff. |
| chameliumEdible: true |
| |
| # 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 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 material buffer gets filled for a single |
| # chamelium. Tweak this if you think printing is too cheap or expensive. |
| materialValue: 2000 |
| |
| # 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 |
| |
| # 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 |
| |
| # 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 |
| } |
| |
| hologram { |
| # 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 |
| |
| # 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 |
| } |
| |
| # Other settings that you might find useful to tweak. |
| misc { |
| # The maximum width of multi-block screens, in blocks. |
| # See also: `maxScreenHeight`. |
| maxScreenWidth: 8 |
| |
| # 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 |
| |
| # 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 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 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 "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 number of ports a single network card can have opened at |
| # any given time. |
| maxOpenPorts: 16 |
| |
| # 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`. |
| maxWirelessRange: 400 |
| |
| # The number of remote terminals supported by each server tier. |
| terminalsPerTier: [2, 4, 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 |
| |
| # 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 |
| |
| # 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 |
| |
| # 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 vertical distance |
| # to the Geolyzer. So yes, on the same height, the returned value are of |
| # equal 'quality', regardless of the real distance. This is a performance |
| # trade-off. |
| geolyzerNoise: 2 |
| |
| # 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" |
| ] |
| |
| # Whether to not show your special thinger (if you have one you know it). |
| hideOwnSpecial: false |
| |
| # 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 |
| |
| # 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 |
| |
| # 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: [] |
| |
| # 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 |
| |
| # 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 |
| |
| # 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 |
| |
| # 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 |
| |
| # Time in seconds to pause a calling machine when the soft limit for a data |
| # card callback is exceeded. |
| dataCardTimeout: 1.0 |
| |
| # 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 |
| |
| # 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 maximum range between the drone/robot and a villager for a trade to |
| # be performed by the trading upgrade |
| tradingRange: 8.0 |
| } |
| |
| # Settings for mod integration (the mod previously known as OpenComponents). |
| integration { |
| # 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" |
| ] |
| |
| # The UUID to use for the global fake player needed for some mod |
| # interactions. |
| fakePlayerUuid: "7e506b5d-2ccb-4ac4-a249-5624925b0c67" |
| |
| # The name to use for the global fake player needed for some mod |
| # interactions. |
| fakePlayerName: "[OpenComputers]" |
| |
| # Vanilla integration related settings. |
| vanilla { |
| # 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 |
| |
| # 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 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 |
| } |
| |
| buildcraft { |
| # Cost to convert a loot disk to another in the BuildCraft programming table. |
| programmingTableCost: 5000 |
| } |
| } |
| |
| # 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 { |
| # 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 |
| |
| # 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 |
| |
| # Disable user data support. This means any otherwise supported |
| # userdata (implementing the Value interface) will not be pushed |
| # to the Lua state. |
| disableUserdata: 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 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 |
| |
| # 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 |
| |
| # 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 |
| |
| # 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: "" |
| |
| # 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 |
| |
| # 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 |
| |
| # 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 |
| |
| # Logs information about malformed glyphs (i.e. glyphs that deviate in |
| # width from what wcwidth says). |
| logUnifontErrors: 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 |
| |
| # Pass along IDs of items and fluids when converting them to a table |
| # representation for Lua. |
| insertIdsInConverters: 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. This will *not* remove the card, it will |
| # just make all functions it provides error out. |
| enableDebugCard: true |
| |
| # 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 |
| |
| # 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 |
| } |
| } |