Jump to content
  • Sky
  • Blueberry
  • Slate
  • Blackcurrant
  • Watermelon
  • Strawberry
  • Orange
  • Banana
  • Apple
  • Emerald
  • Chocolate
  • Charcoal

Leaderboard


Popular Content

Showing content with the highest reputation since 04/01/14 in all areas

  1. 16 points
    MineOS is half the operating system and half the graphical environment for OpenOS, which comes in OpenComputers mod by default. Oringinally it was developed in Russian, but it supports several languages. MineOS has following features: Multitasking Windowed interface with double buffered graphics context Animations, wallpapers, screensavers and color schemes Language packs and software localization User authorization by password and biometrics Support for file sharing over the local network via modems Support for client connection to real FTP servers Error reporting system with the possibility to send information to developers App Market with enormous amount of wonderful applications and possibility to publish your own programs for every MineOS user An internal IDE with syntax highlighting and debugger Open source system API and detailed illustrated documentations Custom EEPROM firmware with the possibility to select/format the boot volume and Internet recovery Almost complete compatibility with OpenOS software How to install? First, you need to install OpenOS from floppy disk to your HDD. After that you'll be able to run MineOS installer via single command: pastebin run 0nm5b1ju System requirements: Internet Card OpenOS installed on Tier 3 HDD Tier 3 GPU 2x Tier 3 RAM Tier 3 CPU (not really matters, just speed up) Troubleshooting: Are there any problems, suggestions? I'll be glad to see you on the operating system repository: https://github.com/IgorTimofeev/MineOS
  2. 12 points
    MoonlightOwl

    Hologram Editor

    1) Install 0.7.1: http://pastebin.com/LPb4FEv4 0.7.0: http://pastebin.com/2kG4V3tB 0.6.0: http://pastebin.com/bR33cXDU You can use internet card, and command: pastebin get LPb4FEv4 holo 2) What do you need a) Diamond Screen and Graphics card (for good resolution). Beginning from version 0.7.0 you can use a golden GPU card. Diamond processor (just faster; before OC 1.4 it's not important) c) 2 Golden memory planks. d) Internet card (to get program from pastebin) e) Hologram projector (to preview your creation) f) other parts, any levels 3) What can it do? This is a simple tool for hologram edition, viewing, saving and distribution (as `*.3d` or `*.3dx` files). You create hologram in layers. (48x32x48 voxels). You can switch between "Top", "Front" and "Side" projections. The editor can show additional layer as "ghost", for comparison between layers. By default this is layer "below" or "above" current. Also the editor allow you to use some hotkeys: '~' '1' '2' '3' for eraser tool or brushes, 'Del' to clear layer. 3DX format is quite lightweight (around 1.4 kB for a complex model). Old 3D format is around 19kB per model, but is easier to parse. 4) What does this look like? 5) I just want to show my model, do I need a full editor tool for this? To "deploy" hologram (any computer, any components), you cant use small `show` tool: 0.7.1: http://pastebin.com/1iW9fX7i 0.7.0: http://pastebin.com/vvxKKGff 0.6.0: http://pastebin.com/ggwXr81P pastebin get 1iW9fX7i show Usage: show filename[.3d/.3dx] [scale] 6) What do you think?
  3. 9 points
    asie

    Introducing "Lunatic"

    No spoiler in the title. Just watch the video.
  4. 7 points
    Hello all, I'm here to announce the release of OpenSecurity! Build Status: Downloads: https://minecraft.curseforge.com/projects/OpenSecurity Change Log: http://ci.pc-logix.com/job/OpenSecurity/changes Source: https://github.com/PC-Logix/OpenSecurity OpenSecurity adds Items and Blocks that are useful for the security of your worlds or bases. Documentation has been moved to GitHub: https://github.com/PC-Logix/OpenSecurity/wiki
  5. 6 points
    XyFreak

    Big Reactors Grid Control

    Hi everyone. A while back I promised more releases, so here you go: Big Reactors Grid Control is a multi reactor/turbine controller for Big Reactors and Extreme Reactors. Mission goal: Be the best big reactors controller there is. Nothing more, nothing less. First things first - here's the website: https://tenyx.de/brgc/ NOTE: Due to a bug with OpenOS 1.7.4, BRGC will not work with that version. Please update to 1.7.5. Main features Active and passive reactor support Support for multiple reactors and turbines at the same time (n:m) Control active and passive reactors with the same controller Automatic configuration of everything (EVERYTHING!) Setup instructions wget the installer from here: http://xypm.tenyx.de/standalone/brgc_installer.lua Run it Done Big Reactors Grid Control comes with three rc.d files: /etc/rc.d/brgc_reactor.lua /etc/rc.d/brgc_turbine.lua /etc/rc.d/brgc_grid.lua If you want the controller to run at boot time, you can just use OpenOS' rc.d schema. There's a GUI as well as a command line utility for advanced users. To start the gui, simply run "brgc_gui" and watch the magic happen. The gui scales the screen resolution to match the screens ratio and should scale with basically all screen setups. I recommend 3x2 or 4x3 screens. As of now the command line utility allows you to do (almost) everything you can do with the GUI and also allows you to change the controllers configuration at runtime (if you so desire). Check out "brgcctrl help" for further information. How to set up the grid In a basic setup you just interconnect everything: All active reactors can output steam to all turbines. All passive reactors and turbines output energy to the same grid. You CAN have passive reactors and turbines output energy to different energy grids. While this poses absolutely NO problem for passive reactors, you will have to set some turbines to "independent"-mode (more on that below). If you want your reactors and turbines to properly cooperate, you'll also need to connect at least one energy storage block to your energy grid. Currently supported storage "blocks" are: EnderIO Capacitors (requires the mod "Computronics") Draconic Evolution Energy Storage multiblocks. RFTools Energy Cells Thermal Expansion Energy Cells Mekanism Induction Matrices You can connect them using OpenComputers Adapters. Discovering new components As mentioned before the controller tries to autoconfigure everything: Passive Reactors When a new passive reactor is connected to the controller, the controller will first try to measure its maximum energy output. The reactor will have its output increased step by step and the average (interpolated) maximum will be used for that value (CALIBRATING). After calibration has been completed, the controller calculates the most efficient energy output of the reactor. Active Reactors When a new active reactor is connected to the controller, the controller will first try to measure its maximum steam output (CALIBRATING). For this to work correctly the reactor must be able to output at least SOME steam (read: you need a consumer) and you will need to provide sufficient ammounts of water. The controller will detect reactors with a potential steam output greater than 50 B/t and limit its energy accordingly. Turbines When a new turbine is connected to the controller, the controller will first try to measure its maximum energy output (CALIBRATING). For this to work, make sure your turbine is built correctly. This means your turbine can be run at maximum supported steam (25mb/t per blade) without exceeding 1950 RPM. Should your turbine exceed 1950 RPM at any stage, the controller will shut down the turbine and flag it as failed. Note: Your turbine is NOT required to be able to process 2000 mB/t. Smaller turbines work perfectly fine. Screenshots After this wall of text, here're some screenshots (pre 4.2). Setup: Main view: Passive reactor details: Active reactor details: Turbine details: Let's go in order: When you start up the GUI you will be presented with the main view. Here a combined overview of passive reactors, active reactors and turbines will be presented. You can click (or touch) on any of these items to open up a detailed view of the component. Here you can enable/disable the component or change its behaviour. What behaviour? This is where it gets interesting. Passive Reactors You will notice that passive reactors have two modes and an "auto" mode. PWM This is the behaviour everyone knows: The reactor gets turned on when its internal energy storage drops below 10% and gets turned off when the energy storage exceeds 90% of it's maximum capacity. In PWM mode the reactor will generate energy at its most efficient rod level. Overall this mode allows the reactor to generate energy as efficiently as possible as long as your actual energy consumption is below or equal to its optimal energy output. But sometimes you need just a bit more energy and you don't want to upgrade your reactor or build a new one. "Classic" controllers will fail to produce sufficient ammounts of energy here. This leads me to the second behaviour: Load In "Load"-mode the reactor will always aim to produce energy at the same rate as it's consumed. Maybe some people already suspect what that mode is all about: It's a PD-like regulator. While "Load"-mode is not as efficient as PWM-mode in situations where the energy consumption is below the optimal energy output, it will guarantee you're never running into energy shortages - provided you're not exceeding the reactors maximal capacity. Auto "Auto"-mode aims to eliminate the disadvantages of both modes by combining them: If the energy consumption can be satisfied with PWM-mode, PWM will be used. If the energy consumption is above optimal levels, "Load"-mode will be used instead. As a result, "auto"-mode generates energy as efficient as possible while always saturating your energy demands. Active Reactors As of now, active reactors only operate in "load" mode. Steam is consumed and produced way too fast and the reactors internal steam storage does not allow for anything else. Turbines Turbines controlled similar to reactors in "load" mode: The controller will always try to balance the turbines internal energy storage out to 50% by using a PD-like regulator. Turbines can be operated in "ganged"-mode or in "independent"-mode, with "ganged"-mode being the default. The only difference between these two modes is that turbines in "ganged"-mode can be shut down by the controller, while "independent" turbines will always be active, even if they overproduce energy at the lowest RPM allowed. This is handy if one (or more) of your turbines produces energy for a seperate (dedicated) energy grid but has to be controlled by the same controller. If such a turbine is not in "independent"-mode it may be shut down which will lead to energy failure in that grid. That's it for now. If you have any questions, want to report bugs, etc., feel free to drop a message here. Also: Do you want an indepth tutorial on how to use the command line utility? Need a description on what the GUI is actually showing? Have fun XyFreak
  6. 6 points
    MoonlightOwl

    Stem - easy internet bridge

    What is STEM? Did you ever want to have a linked card, but without this pair-to-pair limitations? Well, you have internet card. And that is already half of the solution. The other half is to use Stem. Stem is a message transmitter for your OpenComputers devices with internet cards. Using a small OpenOS library you can use Stem to send and receive messages. Unlike the standard `modem` component, Stem-messaging uses not addresses, but `channels`. You can send messages to any channels, and you can subscribe to any number of channels to listen for messages from them. Installation The best way is to use HPM: hpm install stem If you do not have HPM, install it like this: pastebin run vf6upeAN If you do not want to use HPM repository, you can just use wget: wget https://gitlab.com/UnicornFreedom/stem/raw/master/stem.lua Example of a program using STEM local event = require('event') -- use STEM client library local stem = require('stem') -- open a connection to a STEM server -- the `stem.fomalhaut.me` is a default one local server = stem.connect('stem.fomalhaut.me') -- subscribe for messages from the channel with ID 'my-channel-id' server:subscribe('my-channel-id') -- then listen for events in a loop... while true do local name, channel_id, message = event.pull('stem_message') if name ~= nil then print(channel_id, message) end end -- ...or register an event listener event.listen('stem_message', function(_, _, channel_id, message) print(channel_id, message) end) -- you can also send message to the channel -- (you do not need to be subscribed to this channel, to send a message) server:send('my-channel-id', 'hello there') -- unsubscribe from channel server:unsubscribe('my-channel-id') -- completely close the connection to the STEM server server:disconnect() That is all. But there is more. Web client If you open the link to Stem server in your browser: https://stem.fomalhaut.me/ You will see some statistics and the web client. Enter your channel ID into the form, and you can send messages to your robot in real time, right from your phone, without even starting Minecraft. The web client is limited with UTF-8 encoding, though. (Using OpenOS you can send literally anything, as long as the message fits in 64kb of data.) Security Questions The channels by default do not have any special security measures applied. They do not have any authentication mechanisms, the do not have any encryption. Anyone who knows the ID of a channel can send a message to it and can listen for responses. But. The length of ID is 256 bytes. And that can be any bytes - from 0 to 255. That means, that you have 256^256 possible combinations for your ID. And that is a giant number. If you need to secure your channel - just use something long and incomprehensible as your ID. As an additional measure you can use end-to-end encryption, or anything else - this is up to you. Default STEM server uses HTTPS, and does not store any information - message in, message out. Self-hosted STEM solution For those of you who are strong in spirit and computer knowledge - there is a self-hosted option. You can build Stem server from sources and run it on your machine. This is also pretty easy. Additional instructions can be found on GitLab. Useful links GitLab repository: https://gitlab.com/UnicornFreedom/stem Protocol description: https://gitlab.com/UnicornFreedom/stem/wikis/protocol Default server: https://stem.fomalhaut.me/ HPM package: https://hel.fomalhaut.me/#packages/stem If I forgot something - feel free to ask here, or in IRC (my nickname is Totoro there). Also the project contains at least one "Easter egg" feature, that can offer some interesting options if you know HTML/CSS/JS. The Stem protocol is open - you can modify it, you can create your own clients in any programming language, etc.
  7. 5 points
    BrightYC

    Cyan BIOS

    The world as I knew it had a problem. A plenty of bootloaders had already existed, and they'd all shared the same flaw: it wasn't me who made them. I've decided to put an end to that. Cyan is a multi-bootloader and a replacement for the plain Lua BIOS. The features it encompasses include: a whitelist to prevent random strangers from tampering with the computer a Lua interpreter to test your sudden ideas support for hot-plugging filesystems if you've forgot to insert a floppy the ability to format or label a filesystem, while we're at it loading the boot payload from the internet when you can't afford an HDD and a gorgeous, minimalistic design Pictures: To install on OpenOS, run the following: wget -fq https://raw.githubusercontent.com/BrightYC/Cyan/master/installer.lua && installer.lua Or, if you're a MineOS user, look for the program (bearing the same name) at your local AppMarket. Here's how the whitelist works. You add trusted users to the list when the installer asks you. Then the bootloader will ignore any signals from other people. That's it. Oh, and you can also choose a less restrictive option: the Cyan BIOS can wait for input from a trusted user. Before that an authorized person can't access the bootloader. Lastly, a couple of words about the Lua interpreter. It doesn't wrap the output, and the input command must be less than the screen width. The last restriction can be circumvented by copy-pasting the command. In addition to that, the bootloader defines the following functions: os.sleep([timeout: number]) proxy(componentName: string): table or nil — returns a component proxy by its name (cf. component.proxy, which takes an address) read(lastInput: string or nil): string or nil — a primitive io.read() print(...) The source code for the curious: https://github.com/BrightYC/Cyan P. S. Big thanks to @Fingercomp for his lecture about string escapes and writing this text.
  8. 5 points
    https://minecraft.curseforge.com/projects/openpython https://github.com/EcmaXp/OpenPython OpenPython makes micropython available on OpenComputers. micropython is Python for embedded devices and is different from CPython. Currently, micropython is partially compatible with Python version 3.4 as of October 2018. Features include: - Fully persistable. - Runs in a sandboxed environment and does not require a separate native DLL. - Supports virtual file system. - It can call other components and supports Lua architecture's UserData. Limitations include: - The firmware is 256 KB and the memory limit has the same limit as the Lua architecture, but the stack is allocated in a separate memory. - Most modules are difficult to use because the battery is partially included. - The operating system is not yet fully implemented, so the Python interpreter now runs. - Ctrl + C is not supported, so if you accidentally run infinite repeated code, the only way to stop it is to turn the computer off and then on. To use the Python architecture, you need the following items: - EEPROM (OpenPython): I'm sorry, but you have to bring items from the Creative tab. - Floppy Disk (OpenPython OS): This item can be obtained by creating a floppy disk and Scrench, or you can check it on the Creative tab. - OpenPython CPU: You can choose OpenPython architecture by holding Shift + Right Click on the Lua architecture CPU. It is still unstable, but we plan to make further improvements in the future. I need help from people who are familiar with OpenComputers and Python. Thank you for playing.
  9. 5 points
    I decided to make an editor with syntax highlighting, just for the fun of it. The name stands for "syntax highlighting editor", it's very unoriginal, but I'm bad at names To use it, run this command on OpenOS: pastebin get ZnwyunqL /bin/shedit.lua The color scheme was (sorta, I redid it later) copied from this paste. Features: Syntax highlighting! Indent on enter Line numbers Jump to line Hex colors are highlighted with the color they refer to (example: ) And probably more in the future if I need them.. Screenshot: Any recommendations or comments are appreciated!
  10. 5 points
    its_meow

    OpenScreens

    OpenScreens for Minecraft Forge 1.12 to 1.12.2 OpenScreens adds more display options for OpenComputers. Curse Link: https://minecraft.curseforge.com/projects/openscreens Holo Screens Holo screens are floating displays with adjustable size and color. Hologram projector model and texture by ZefTheFox Right clicking a holo screen with a dye will change the background color. Right clicking the sides with an empty hand while crouching adjusts the size of the display. Flatscreens Flatscreens are simple displays that are... flat! There's two types, one on the front of the block and one on the back to allow more freedom. I have questions/need support! Where can I get help? You can always ask in my Discord server. If your issue is related to OpenComputers, you can read the OpenComputers Wiki. Report bugs here. My website: https://itsmeow.dev/ Discord Server: https://discord.gg/zrjXjP5 Curse Link: https://minecraft.curseforge.com/projects/openscreens
  11. 5 points
    This program can display the contents of tanks on a big screen with a colored bar that can dynamically change its size. It can show up to 256 128 64 different liquids which are sorted from highest amount to lowest. 5x8 is the optimal size for the screen. Multiple tanks with the same liquids are automatically added together and empty tanks are ignored. This display is split into 2 programs. 1) Server - this receives the tank information and displays it 2) Client - this has the adapter with the tank controller (you can have as many as you like) optimal screen sizes: 8x5; 8x2; 4x1 pastebin run -f cyF0yhXZ installation guide: https://www.youtube.com/watch?v=avvYO2xSxGw github: https://github.com/Nex4rius/Nex4rius-Programme/tree/master/Tank#start server / display components: Internet Card (to install) Network Card Graphics Card T3 Screen T3 client / adapter + tank components: Internet Card (to install) (Wireless-) Network Card It supports now the following blocks: Adapter + Tank Controller Upgrade Transposer Batbox CESU MFE MFSU Gregtech Batterybuffer Capacitor Bank ALL RF storage blocks ME Interface ME Controller Warded Jar Void Jar Big Update version 2 The screen scales better to utilize the "room" to the fullest. Thaumcraft: I've added support for jars and essentia (Thaumcraft 6 needs the Thaumic Computers mod) ExtraCells: It's now possible to connect this to the ME System and read all liquids from it. Thaumic Energistics: Additionally it can read essentia from the system if you have Thaumic Energistics installed. Energy EU: You can connect EU storage devices and it will show it on the screen. Energy RF: Furthermore you can also connect any RF storage block and it will work too. The version 2 is not compatible with the version 1. You will have to update the server and all clients. I've double the limit from 64 to 128 and doubled it again to 256!
  12. 5 points
    Features: FlatScreen Panel frameless screen which can be configured to be "rotated/tilted" on the x/y axis and can render transparent (they work as normal Screens, Touchinput will be improved in the final release) CardDock external housing for OpenComputer Cards which can be bound to any machine in the Network Cases additional Tier3 computer cases from ZefTheFox Download on curseForge for Minecraft 1.12.2 https://minecraft.curseforge.com/projects/ocdevices
  13. 4 points
    IlynPayne

    SGCX - SGCraft Stargate Controller

    SGCX - SGCraft Stargate Controller Stargate controller based on GML library. Showcase: Installation steps: First download the package manager that will be used to download the application and all required dependencies: wget https://pastebin.com/raw/iAH5xC3b arpm_downloader.lua arpm_downloader Use the package manager do download SGCX: arpm install sgcx Run SGCX with an additional argument - init. This will allow you to pick a stargate interface address from list. It is required only during the first startup - address will be saved in a configuration file. sgcx init Optionally you can install the irisAuth package (remote iris management) using the previously mentioned package manager. Features: Displaying Stargate status Storing gate addresses Grouping and searching addresses Disconnecting wormhole after specified time Automatic iris control (see installation steps, step 4) Displaying distance to the selected destination Address calculator: convert addresses within one dimension into chunk (and estimated block) coordinates and vice versa Animated dialing sequence with chevron drawings Future plans: Dialing history Iris authorization usage history Requirements: Tier 3 screen and GPU At least 1 MB RAM Network card Keyboard (GitLab repository)
  14. 4 points
    I just finished the first version of bundle - a rc application which virtually merges multiple filesystems into a bigger one. You can use it whenever a RAID full of tier 3 HDD isn't enough for your needs. On the picture above, for example, you can see 10 RAIDs with 30 tier 3 HDDs which yield a virtual HDD that can store over 200MB of data. You can also use filesystems of different size and create files bigger than any of the used filesystems since bundle is capable of storing a file on multiple HDDs. If you encounter any bug, please report it on my github repository. Also check out the wiki page. How to use it First of all you can download it from pastebin (id: TmeSNidd) or my github repository and install the file in the directory for rc script (/etc/rc.d/bundle.lua). Before using it you should configure the constants at the top of the script in accordance with their descriptions. Otherwise Bundle might work incorrectly. Then you need to add some filesystems by executing rc bundle add [address] in the shell. Please replace [address] by the address of the desired filesystem. Doing so wipes the added filesystem. However, Bundle never incorporates filesystems automatically. Next you should allow bundle to run in background by executing rc bundle enable Just reboot the computer and it should be listed by df Note that the label of the first added filesystem and the filesystem provided by Bundle are always equal since that's the way how bundle stores it. You can also view the added filesystems by executing rc bundle list You can also remove added filesystems by rc bundle remove [forcefully] Currently, this just removes the last added filesystem, however. If the removal causes the lose of data this fails except you set [forcefully]. Usage notes Don't install the OS on a Bundle filesystem since Bundle requires some functions of OpenOS. Bundle uses a virtual copy of the file structure. On the one hand this makes "hardware" operations faster, on the other hand it might lead to errors when running out of memory. Bundle works with Lua 5.2 as well as Lua 5.3. Known bugs Seek operations that set the current position to a value that is bigger than the size of the file cause the file the become bigger than its actual physical size. This is also the case on filesystem components of Open Computers but with bundle it might cause internal errors. That is it for now, have fun using Bundle.
  15. 4 points
    BIG UPDATE! I've worked out some updates and a new visual editor for the gui system. To use the gui just download http://pastebin.com/Dfgc6z0T to a computer as /lib/gui.lua and try your best. If you don't want to fight with the placing of elements on the screen, then you want to use the visual editor. It's alpha state, but i hope it will make no errors. The editor will create a full lua code as frame work for your own program in resolution 80x25 like for a tier 2 screen. But you need a tier 3 screen to use the editor it self. The program you can run then on a tier 2 or tier 3 screen. Please try it and let me know, what you think. It's a bit flickry when updating the screen, but i hope i get this fixed. You can download the editor at https://pastebin.com/jdaM8FKG If you like it, let me know and tell me, what i could change, or what you want me to put into the gui or the editor. Have fun
  16. 4 points
    Log

    GPS on microcontrollers

    Program and library for building GPS network. https://github.com/DOOBW/OC-GPS Download: wget https://raw.githubusercontent.com/DOOBW/OC-GPS/master/usr/bin/gps.lua /bin/gps.lua wget https://raw.githubusercontent.com/DOOBW/OC-GPS/master/usr/lib/gps.lua /lib/gps.lua The functionality is the same as in the ComputerCraft. Additional command "flash" allows to upload firmware to EEPROM. When the coordinates are precisely determined, when flashing the position of the microcontroller can be omitted - at the first start it will determine its position from neighboring satellites and save on EEPROM. GPS network startup example.
  17. 4 points
    This is an object-oriented library, the main priority of which is the maximum possible performance. It works on the double buffering concept, it has a lot of widgets, animations and custom event handlers support. All programs from the screenshots above are implemented with its help. If you want to develop a fast and beautiful program in just a few lines of code without butthurt - then this library is made for you. Detailed illustrated documentation, installation methods and tons of practical examples are available at: https://github.com/IgorTimofeev/GUI
  18. 4 points
    Fingercomp

    Guide to the Sound Card

    The sound card is added by Computronics, a wonderful addon for OpenComputers. There are a few who actually know what it does. Even less people are able to use it. No one dares to understand how it works, or so I hope. Anyway, it appeared a few years (?) ago, and is still mostly undocumented. There is a page in the in-game manual, which fails to explain how great the card is. Of course it does! It has a heap of different methods, which you can use to cast many crazy magics to make the sound card sound, and it's impossible to teach someone to do magic by reading a single page. OK, I'm serious now. Last year I managed to understand how to use it, and even wrote a few posts about that. In Russian. Half a year later, I translated them to English. And now I thought of posting a topic here so that you could read them, too. Here's the link. The first two parts are all about basic things, like getting simple sounds, ADSR, and modulation. The third part features a little bit more complex things, like complex numbers and Fourier transforms. I tried to keep it simple, so I could get something wrong. If so, please leave a comment there pointing out the mistake. Grammar fixes are also highly appeciated.
  19. 3 points
    Due to quarantine, I got a bunch of time in my hands, I remember that since I first used this mod, back in MC 1.7 we had this phrase on Geolyzer description "It is theoretically possible to eliminate this noise by scanning repeatedly and finding an average. (Unconfirmed, needs further testing.)" Now, many years later, i do know quite some about statistics and got plenty of time So, lets begin We begin our dive in Statistics with an hypothesis, Does this number measured relate to an ore or stone, putting it in hardness terms, does the true number of hardness equal to 3(ores) or 1.5(stone), now we estabilish our null hypothesis. The null hypothesis is which one of them I want to minimize the most(it will make more sense in a bit), I prefer to avoid losing ores, therefore my null hypothesis is that the true hardness of the number measured=3 unless proven with enough evidence the contrary(again, more sense later) In statistic we have two kind of erros given in the table below, we want to minimize error type 1 even if type 2 grows, not so much as for example, mark every where as ore, 0 type 1 error and 100% of type 2. Or be it random where both errors are 50%, so we have to have a small type 1 error without gigantic type 2 error ,let's try. I will from now on ommit "error" in type1 error. Let's first analyze on what I believe is the most traditional way, checking if a number is bigger than a threshold , I made a code to help me with that(DataCollector), given a line of 32 blocks, it will go through each one of them, measure 1000 times, and separate in intervals of 0,25. The result is given as every number smaller than the first column It's quite hard to see it all, comparing it with a stone would be disastrous, but we can clearly see a pattern of every 4th increasing in one more row, so make it goes from 0 to 4, to 8 to... to 56, when possible I tried to use an exact distance, for example 40=sqrt(12^2+32^2) when not possible a very close number 56=sqrt(32^2+32^2+32^2), compare stones and ores side by side and we get this: based on this we can see the strengths and weakness of a single or multiple threshold, in my code I tried to give a general approach, so if you want to detect any other pair it's possible. In my code, I used 2 variables, one to know the value when they meet, the distance where they meet, given by (Hhard-Lhard)*8, the second one is Havg, (Hhard+Lhard)/2, it gives the number when they meet. If the distance is smaller than "meet", the value will be bigger or lower than Havg but I will be sure after this check If we use a single threshold of >2.25 we would be fine up to 12, after our errors would be: 16: type1=10.9% ; type2=11.4% | 20: type1=21.7% type2=19.2% | 24:type1=24.7% type2=23.9% | 28: type1=29.8% type2=26.7% | 32:type1=29.6% type2=32.7% As we can see, not good, not terrible if we want to be sure that its a stone or an ore, we must know what is the distance, find this new threshold, it could be done for each one of them but I dont see a particular distribution, but every 4 distance we have a good approximation of a uniform distribution( where every value is as likely to happen), but between them it wont affect that much the chance of being wrong, type1 and type2 errors are equal to: 16: 24% | 20: 42% | 24: 50.4% | 28: 58.1% | 32: 61.8% | 36: 65.8% | 40: 70.5% | 44:73.9% | 48: 75.4% | 56: 78.5% it seems bad to do it that way, we said earlier that our objective is to minimize type1 error, but we can use multiple measurements to decrease the error, we were already going to do that anyway for our second kind of analysis, I chose to do 6 but you can pick another number, I tried to make it easy to change in the code, butt keep in mind that every measurement takes a lot of time and energy, using the geolyzer is time consuming, for each time you add 55 seconds to scan, default(6) is about 5min 30s. The new errors after six times are, (error)^6: 16: 0.1% | 20: 0.5% | 24: 1.6% | 28: 3.8% | 32: 5.6% | 36: 8,1% | 40: 12.2% | 44: 16% | 48: 18% | 56: 23.4% This is already much better, lower error compared to previus test, but this is still very high, we always have 32 distance, the height, with each command and with this test we would have a high chance missing anything, the robot would have to go around or increase the number of tests that adds up for a lot of time and energy, for such a poor result Now we begin using statistical theory, for that we need to know how the variance behaves given a distance, using Variance.lua code changing x and y and Variance1.lua to Z axis. This code gives Standard Deviation this represents how much from the mean it can be. plotting it in a graph we get that the standard deviation is given by approximately 0.35*distance. https://www.khanacademy.org/math/statistics-probability/sampling-distributions-library#what-is-a-sampling-distribution as this free class explains, the distribution of samples is a normal distribution, doesn't matter the original distribution. to visualize it, using DataCollector.lua code add ore nSamples to your code, default is 1, therefore it shows the original distribution now I am doing it with 6 samples the threshold for the average to given the Z value on the Ztable below is given by -Z*StandardDeviation(0.035*distance)/sqrt(nSamples(6)) + oreHardness(3)=OreT, Z is my type 1 error, my type2 error is given by StoneHardness*sqrt(nSamples)/(Z{positive now}*SD)=OreT. This is all a mess I know, lets give it some numbers, let's get a Z value equivalent of 5% wich is about 1.64 or 1.65, I will go with 1.64, distance of 56, we get -1.64*1.96/2.44+3=1,68, to find our type2 error we have Z=1.5*2.44/(1.96*1.68)=1.116 which is equal to 13.1% 16: type1=5% type2=0.6% | 20: type2=1.9% | 24: 3.6% | 28: 5.3% | 32: 7.2% | 36: 8.8% | 40: 10% | 44: 11% | 48: 12% | 52: 13% | 56: 13,5% We can see that this is the best analysis until now overall, mainly on bigger distances, also even though its hard to understand, its super easy to implement it on code, but this analisys and the last one can be thought as independent events if we do both analysis we significantly lower the chance of any error for 56 distance we have type1=1.1% type2= 3.5%, wich is super low, but for my code I chose to do it until 40 of distance or 32^2+32^2+16^2=40^2, for me 1.1% is huge yet and 16*32*32 is enough volume but you can tune it to whatever you like I want to bring to attention that the code of both analysis was done with the ability of taking any pair in mind, be it dirt and stone or stone and ore, or ore and diamond block, it must have a decent enough interval tho. also it checks for anything lower than stone or bigger than ore, must do another analysis to remove the ones you want from it. https://github.com/gabiiel/GeolyzerOreFinder PS: I am not a professional coder or anything like that, I just wanted to burn some quarantine time, any questions or improvements or features, I am willing to help. I hope everyone could understand. Also I am leaving up to you guys how to get to the ores, this is a very low end program that can run on any machine, the ores are stored in a string there is a function to help write and read from it DataCollector.lua variance.lua variance1.lua
  20. 3 points
    FlatDB is an implementation of SQL (or SQL-like) commands for manipulating databases on the hard drive itself. This post covers: Available commands and overview. How to use the API. Limitations. Performance. Future plans. 1. Available commands and overview. The following commands are available within the API: SELECT DELETE UPDATE INSERT WHERE AND OR Tables are human-readable and a single-row table will typically look like this: #$ID|param1|param2 1|value1|value2 Tables are created as files, with their columns (including headers) separated by the "|" character, and their rows separated by "\n". If you want to use any of those characters in the values you want to store in the table, please remember to replace them with another character or string, or they might break the formatting. Here are some syntax and command examples: SELECT * FROM example -- the wildcard (*) will pull all the results from the table. SELECT name|surname FROM example WHERE name = john OR surname = smith -- parameters for selection MUST be separated by "|". SELECT surname|name|age FROM example WHERE age >= 24 -- parameters are returned in the order they were requested. -- With WHERE, AND and OR you can use "=", "!=", ">=", "<=", "<", and ">" DELETE FROM example -- WARNING: calling DELETE without any OR, AND or WHERE statemens will delete the entire table. DELETE FROM example WHERE $ID = 4 -- this will delete only the row with the ID of 4. Note the '$' character. It is used to signify an auto-enumerated field. UPDATE example SET name = jack|surname = jackson WHERE age < 40 -- as with SELECT, the values for SET are separated by "|". INSERT INTO example VALUES (john|smith|32) -- the values need to be wrapped witin brackets "()" and separated by "|". -- if your table has an auto-enumerated field, you don't need to supply that one. However, the rest must be given. 2. How to use the API. First, you need to download it: pastebin get hCyKeJYT flatdb.lua Then, you'll need to call the API: local flatdb = require "flatdb" Since you don't have a database, you have to create one: flatdb.newDatabase("example") -- example being the name of our new database Now, you need to 'connect' to the database, or in other words, tell the API which database you're using: flatdb.connect("example") -- returns true or throws an error if the database doesn't exist. Next, you need to create a new table: flatdb.newTable("table", "$ID|name|surname|age") -- table being the name of the table, and name, surname, and age being the headers we want to insert. -- The "$" before ID signifies an auto-enumerated field. Now, because you're connected to a database, you can start inserting values: flatdb.query("INSERT INTO table VALUES (john|smith|32)") -- there is a neccesary space between VALUES and the open bracket. -- the values we're parsing must be separated by "|". -- currently, it is not possible to pass only the values you want. If you don't have, for example, a surname, -- you can pass "unknown" or something that can be changed later on. Let's say your name is John Doe, not John Smith. And perhaps you're 25, not 32. Maybe you want to change that: flatdb.query("UPDATE table SET age = 25|surname = doe WHERE name = john AND surname = smith") Let's get some data from the table: local result = flatdb.query("SELECT $ID FROM table") -- a statement like this grabs the IDs of every row in the table. -- NOTE: if you're testing from the shell, don't use the 'local' keyword. You might have noticed that a result is returned. Every query returns true upon completion, except SELECT. The SELECT query returns an io.lines iterator, so you will need to loop through it (in our case, we only have one row, so it will loop exactly once): for row in result do print(row) end The io.lines iterator points to a file that contains your output. Depending on what you selected, this file may contain entire rows of the table. How do you get rid of those pesky separators? Let's say we ran this command: local result = flatdb.query("SELECT * FROM table") When we loop through it, we have to split the values into an array to manipulate each column individually. The API provides a splitString function. for row in result do columns = flatdb.splitString(row, "|") -- the splitString function requires a string and a dilemeter (in our case "|"). print(columns[2]) -- because we have a table that's $ID|name|surname|age, this will print only the names end When you're done with a database, you can disconnect by using: flatdb.disconnect() 3. Limitations. The syntax has to be followed somewhat exactly. Spaces in things like "name = john" don't matter, but the space between "VALUES (john|doe)" does matter. When in doubt, double-check the syntax. Everything is done iteratively. The result of SELECT forces you to process the data you returned row by row. Why? Because of the memory limitations of OpenComputers. If a table gets big, there's no way to store it in memory. The first version of FlatDB stored everything in memory as tables (arrays), but that only worked up to a point. This version (a re-write of everything except the logic) is able to work on a computer with 256k memory (Tier 1.5). If you want to break the code, you will be able to. Error checking is implemented, but I can only imagine what possible inputs I've overlooked, and I'm looking forward to fixing that. And it goes without saying (though I'm saying it) - you need the proper amount of space to store this file and the databases / tables you want to work with. Also, I will state again that you can not use "|" nor "\n" in the values you're inputting. If you need that kind of thing, replace them with something else. 4. Performance To test the performance of the library, I set up a computer of the lowest tier that's supported. (Everything is Tier 1, except for memory, which is a single stick of Tier 1.5) I then created a script that will fill a table with random number values between 1 and 100. These are the results of tests: Insert 100 - 21s Read 100 - 1s Read 100 (one discriminatory statement) - 8.5s Read 100 (two discriminatory statements) - 16s Update 100 (one discriminatory statement) - 16s Again, this is on the lowest tier PC. I'm happy with the performance, but I'll improve it where possible. 5. Future plans. Future plans by priority are: Bug fixing Adding error checking Adding new features (I'm looking at you, TOP, MIN and MAX). If you want to submit a bug, please include what the bug is, how to replicate it, and (if possible) the table you're working with. If nothing else, this was a fun exercise.
  21. 3 points
    Log

    Robot-miner with geolyzer

    I present you a program for a robot that allows you to mine ore without going down into the caves. Robot, using a geolyzer, can find and mine ore. All features are not yet implemented, so I ask you to test and inform me about a bugs. Requirements: Computer case (tier II or III) Inventory Upgrade (more the better) Inventory Controller Upgrade Hard Disk Drive EEPROM with Lua BIOS Geolyzer RAM (tier I or higher) CPU (any) Hover Upgrade (tier I) Diamond pickaxe or equivalent tool Optional: Crafting Upgrade Wireless Network Card or Linked Card Solar Generator Upgrade Battery Upgrade Experience Upgrade Chunkloader Upgrade Generator Upgrade Enderchest from EnderStorage mod Installing: Download and save the file as init.lua wget https://raw.githubusercontent.com/DOOBW/geominer/master/miner.lua init.lua Put this file in to root directory of the hard disc. Add the disk when crafting a robot. Place the robot on a solid blocks platform. Give the robot a pickaxe Place a container and the charger near the robot. Press the power button and enjoy a process.
  22. 3 points
    Ever needed real-world time in OpenComputers? I did today, so I did something about it. realtime realtime is a set of libraries and protocols designed to let you synchronise your computers with the real world, and includes: The realtime library, for taking and keeping time. The realtime-sync daemon, for synchronising your realtime library with the real world The realtime-relay daemon, for synchronising your realtime across the local network. All of these can be downloaded via oppm, or from the Minitel GitHub repository. Additionally, all of these come with manual pages describing their functionality and usage, all of which can be found here.
  23. 3 points
    Fingercomp

    Drone usage?

    Of course there is. Assembling a drone with a leash upgrade produces a drone that can transport cows, horses, sheeps, and pigs. Like this: Or... like this: Besides, drones are entities. They move in straight lines; they don't get stuck in the fence and can actually enter a house through a door. They move pretty fast — about 6 blocks a second (robots are at least 2 times slower). Drone's movement is asynchronous, so the machine can execute some other code in the middle of the flight. Drones can fly above the block height limit. The screenshot above was made while enjoying the flight at a height of 260 blocks, for example. Oh, they can fly below the bedrock, too. Also, drones look cool. Jobs at which drones clearly outperform robots include player transportation (thanks to the leash upgrade) and item transportation (due to their mobility). And, if used with robots, drones can be useful for crop farming, autocrafting, and construction, for example.
  24. 3 points
    Luca_S

    advancedLoader - Better BIOS

    This BIOS allows you to choose the boot device by either using the arrow keys or clicking/touching the monitor. When using the keyboard use Enter to boot, when using clicking/touching click an unselected entry to select it, click a selected entry to boot it. If there is only one bootable medium, that medium is autobooted. The default selected option is the last booted device. This supports booting from filesystems, using /init.lua as an entry point or from drives(HDDs or Floppys in unmanaged mode), by loading code from the first sector until the first \0 character appears as lua code. (From what I've seen unmanaged drives are mostly ignored in OC, which is kinda sad.) Screenshots: To install: (This file contains the code needed to flash the BIOS as well as the BIOS code itself, it will ask before flashing it to the EEPROM) pastebin run Cx4aTipt
  25. 3 points
    OpenOS has absolutely proper pipes now, such as those you invoke with `cat file | grep foobar`, and a kick butt threading library (read https://ocdoc.cil.li/api:thread ) As for virtual components? No, there is nothing built into OpenOS for virtual components, but gamax92 has written a nice vcomponent library you can add via oppm, `oppm install vcomponent` Plan9k is retired, to be honest. It was ahead of its time, but is now outdated. OpenOS is faster, lower memory, has gobs of great libraries, super awesome command line parsing, and is ACTIVELY developed. I might be biased....
  26. 3 points
    Fingercomp

    make opencomputers processors faster

    Please calm down. There are some component methods that block the computer for a tick when called, yes. Such methods usually interact with the world. For example, a transposer allows to transfer items between invetories by calling the transferItem method, which takes a tick to execute (so you get up to 20 stacks/second). On the other hand, there are a lot of direct methods, which can be called several times per tick. For example, the GPU's methods are direct. And the processor (as well as RAM) determines how many direct calls are allowed per tick. I think T2 T3 setup allows you to call gpu.get one thousand times every tick. Or 256 gpu.sets. Or 128 gpu.fills. I also believe you don't realize how bad ComputerCraft is for servers. A really simple and stupidly-written program can eat up all the memory the server has. That's why OC limits the memory available for an in-game computer. And running CPU-intensive tasks on a CC's computer makes the whole server run slow, whereas OC requires scripts to pause to allow other in-game computer to run. OpenComputers imposes the limits not because the mod developers want users to suffer (although I do sometimes think of that when I try to do some stupidly complex things with it), but to make it server-friendly. What's important is that OC allows you to configure these limits for your needs. Have you opened its configuration file? It is more than a 1.5k lines long, and has more than 300 settings you can change, each with a comment that explains the effect of the setting. There's callBudgets to increase the direct call number limit. Or decrease it. There's also the ramSizes setting for memory, and hddSizes for the HDD sizes. But even with all of these limits, OC can run a lot of programs, including graphical shells, 3D games, reactor control systems. It allows you to send HTTP requests to the real websites, and open raw TCP sockets to interact with network services. It can display 320x200 images. It can even play videos — inside the game, and on the default OC settings!
  27. 3 points
    Sangar

    OpenPrograms

    There is a Github organization named OpenPrograms which a couple of us use to share our OpenComputers related programs. Feel free to have a look, you may find something useful there! If you wish to contribute / have a repository in that Organization, just ask - either here or on the IRC. OpenPrograms on Github The OpenPrograms program list
  28. 2 points
    Zen1th

    Minecraft server on OC

    Last demo video: No, it does not currently run modded minecraft (albeit it runs plugins made for this server), but one experiment i want to do for later is recreating a bit of OC mod in Lua, to make it run in this server, so that you can run Minecraft server in Minecraft server in Minecraft server in Minecraft server in ... until it crashes your PC lol.
  29. 2 points
    KestrelOS GUI-based, Windows-alike, highly customizable, and safe Operating System for common pourposes What's the major GUI-based OS currently available? The amazing system created by Igor, called MineOS (I'm sure everyone by now knows about it). Igor's system is based on OpenOS, that looks like MacOS and is by itself the most amazing system released yet, with all sorts of programs and even 3D libraries which is mind blowing. So why create yet another GUI-based system? There are several reasons why I decided to take on this journey. First of all, the majority of OS's out there, including MineOS is based upon OpenOS, which makes it a bit streamline and boring, but also unsafe. KestrelOS is made entirely from scratch with it's own libraries, services and style. I wanted to create something new, that would give less freedom than OpenOS (which is KestrelOS's main disadvantage), over a much more secure way to process applications. I also wanted to make KestrelOS as simple as possible, so anyone that is familiar to Windows will recognize most of it's content. How exactly KestrelOS works? KestrelOS implements safety policy, where only so called "managers" have absolute control over the system's event management. The "heart" of the system is a manager called "taskman" (Task Manager). Every other manager is registered to taskman and is a read-only table with functions that cannot be altered once the system has booted up. This restrains a lot of freedom for the user, but also prevents malicious software of changing core functions of the system in order to spy or corrupt data. There is few core managers that will "steer" every process in the system, taskman being the most important one as it is the only library in the entire system that has access to a now unavailable command: computer.pullSignal This forces every application to register itself into taskman in order to be able to hook itself under the heartbeat. What is this weird "heartbeat" you're talking about? Taskman has a loop, in which it listens for any signal. I called it the heartbeat, because it waits only 0.25 of a second to update any tasks hooked under specific processes even if nothing happens. This allows multitasking, or for example updating the clock on the bottom-right of the screen What are the so-called "managers" doing? Those so-called managers are here to serve programs with several system services. For example, there's a manager called "driverman", which loads system drivers, which are usually a single library that communicates with a specified type of component. There's a driver for graphics, which is communicating with the GPU, but uses Igor's amazing double-buffering technique (although I made my own version of it from scratch, but it is very primitive right now) to draw into the screen. Drivers are basically bridges between gpu's, datacards etc. that make sure such a given component is available and return optimized methods to use those components better. Of course, every driver has it's own version, name, description, and can be retrieved manually from driverman using the driver id or name, in case you'd like to implement your own driver and use it. What other features it has? Well, most of the system features are actually the managers which act as the main "pillars" of the system. Here's few of main managers that I remember as of now (as I'm not on my home PC right now, I'm writing from my work PC): driverman - manages drivers fileman - manages mounts for different filesystems and resolves path using mounts taskman - heartbeat of the system, manages processes and tasks assigned to those processes regman - manages system's registry guiman - uses kgraphics driver from driverman to draw complex GUI elements on the screen ... (there's a few more that I can't remember now or that are under development) ... Any concerns/disadvantages? Well, like stated before, it actually restrains quite some core functions to prevent malicious application of accessing those in order to prevent system spying or corruption. This removes quite a lot of freedom, but once you log in and unlock everything, you should be able to edit that manually in the system files if you so desire. Any pictures? Well I'm on my work PC not at home so I can't do any pictures, what I can say is that most of the baseline managers are implement and that I'm working on the GUI now, so don't say hurray yet as I'm working on it. Sorry Release date? Undefined.
  30. 2 points
    Anything not impossible is possible, and this feature doesn't even require much perseverance to implement. Right now we're using owner to store the nickname of one player. We are going to replace it with a table, and therefore the name owner is no longer satisfactory. Let's rename it as trustedPeople and populate it with some test names. local trustedPeople = {"player1", "player2", "player3"} A table is the universal record type in Lua, that is, the type that stores multiple values. But we still need to choose the correct data structure. The table trustedPeople is a sequence. This means its elements are stored sequentially, without gaps, and can be accessed using integer indeces (trustedPeople[1], trustedPeople[2], etc.). Such a data structure is useful if we need an ordered collection of items to iterate over, for example. However, this is not the case here. What we need is essentially a set, which stores unique elements and can tell us in an efficient way if a certain value exists. In Lua, sets are usually implemented as follows: local trustedPeople = { ["player1"] = true, ["player2"] = true, ["player3"] = true, } The stuff in square brackets is called the key, and what follows after the equals sign is the value. If you have the key, you can quickly determine the associated value, which defaults to nil for nonexistent keys. The most important word is quickly. As for the previous data structure, to find if a table contains a trusted person, we would have to iterate over the sequence of authorized players for every element of the table. local ownerNearby = false for _, entry in ipairs(scan) do for _, trusted in ipairs(trustedPlayers) do if entry.name == trusted then ownerNearby = true goto out end end end ::out:: It's very inefficient and complicated. Now, compare it with the code that we would write if we use a set for trustedPlayers: local ownerNearby = false for _, entry in ipairs(scan) do if trustedPlayers[entry.name] then ownerNearby = true break end end However, I like how easy it is to modify the sequence in the code. {"one", "two", "three"} is much more concise than {["one"] = true, ["two"] = true, ["three"] = true}. I'll make it so that we could specify the list of allowed people, and it would be converted to a set by the program. local trustedPeople = {"player1", "player2", "player3"} for index, nickname in ipairs(trustedPeople) do trustedPeople[nickname] = true trustedPeople[index] = nil end Let's incorporate all of that in the original program. local component = require("component") local alarm = component.os_alarm local door = component.os_door local entity = component.os_entdetector local trustedPeople = {"player1", "player2", "player3"} for index, nickname in ipairs(trustedPeople) do trustedPeople[nickname] = true trustedPeople[index] = nil end local previousState = "nobody" while true do local scan = entity.scanPlayers(64) if scan and #scan > 0 then local shouldOpen = false for _, entry in ipairs(scan) do if trustedPeople[entry.name] then shouldOpen = true break end end if shouldOpen and previousState ~= "allowed" then door.open() alarm.deactivate() print("Welcome home!") previousState = "allowed" elseif not shouldOpen and previousState ~= "intruder" then door.close() alarm.activate() print("Hello, whoever you are.") previousState = "intruder" end else door.close() alarm.deactivate() previousState = "nobody" end os.sleep(2) end I've also changed a couple of names so that they would reflect their purpose.
  31. 2 points
    I am sorry, but unless I'm misreading your code, it can't possibly throw an "attempt to index a nil value" error, with any people in proximity or without. And the question is contradictory, stating both that the program crashes and that it freezes (the latter is correct, however). Actually, I'm unsure what the actual question is. Therefore, I'll do the only thing I can here: that is, explain what your code does wrong and how to fix it. Before I can proceed to fix the actual issues in the program's logic, I have to get rid of some minor problems. The first such problem is that the code is indented poorly. Of course, Lua doesn't care how you format your code, but it isn't why you do that. Indentation helps you, the program's author, to keep track of what it does, to visually separate chunks of code. And other people benefit from that too, for properly formatted code is much more readable. Without further ado... local component = require("component") local colors = require "colors" gpu = require("component").gpu alarm = require("component").os_alarm door = require("component").os_door entity = require("component").os_entdetector local w, h = gpu.getResolution() local delay -- sleep time local player -- list of players while true do os.sleep(2) if entity.scanPlayers(64) == true then scan = entity.scanPlayers(64) name = scan[1].name if name ~= "sav" then door.close() alarm.activate() print("Hello " .. scan[1].name) os.sleep(2) alarm.deactivate() elseif name == "sav" then door.open() alarm.deactivate() print("Welcome Home Sav") os.sleep(2) end os.sleep(4) end end ...And the second thing to take care of is the global variables. Unless you need them such (which rarely happens and this is no exception), make them local. Finally, you've already required component, so there is no reason to do so again; and, while fixing that, let's also remove the unused variables: gpu, colors, delay and player. You can re-add them later yourself if you need. local component = require("component") local alarm = component.os_alarm local door = component.os_door local entity = component.os_entdetector local owner = "sav" -- insert your nickname here while true do os.sleep(2) if entity.scanPlayers(64) == true then local scan = entity.scanPlayers(64) local name = scan[1].name if name ~= "sav" then door.close() alarm.activate() print("Hello " .. scan[1].name) os.sleep(2) alarm.deactivate() elseif name == "sav" then door.open() alarm.deactivate() print("Welcome Home Sav") os.sleep(2) end os.sleep(4) end end Great, so now we can start dissecting the code. What does it do? First, we require the component library, get proxies of the components we need, and proceed into the main loop. There we first sleep for 2 seconds... Why do we sleep for 2 seconds, again? I'm not sure; let's keep it there for now. Then we perform a scan, calling entity.scanPlayers(64), which returns a table, and compare if it is equal to true. Wait. There is no way a table can be equal to true, not unless you mess with metamethods, which we don't. Very suspicious. If we interpret the code literally, we skip the whole if, and end up at the start of the loop again. It's not interesting, so let's pretend that somehow the if's condition is satisfied to understand what the author's intent was. And then we perform another scan... hang a minute, another one? Haven't we already done that? Why should we be in dire need of repeating ourselves? Anyway, I think I realized what the code was supposed to do: scan the surroundings and check if there's anyone around. After all, running an alarm without anybody to listen to the marvelous sounds of it is just a waste of energy, isn't it? Let's put it into words in Lua. ... while true do local scan = entity.scanPlayers(64) if scan and #scan > 0 then ... else door.close() alarm.deactivate() end os.sleep(2) end We do the scan as soon as we're in the loop. If the scan result is present (neither a false nor a nil), which means the entity detector had no errors, and the length (#) of that table (#scan) is greater than 0 (#scan > 0), then we'll do something about it. The previous sentence is basically how you'd read the code in English. Note that if scan happens to be empty, we close the door and disable the alarm. And we shouldn't forget to sleep, for the sake of energy conservation. All right, so let's do something about the scan. scan the variable is a table of tables. In other words, scan is a table that stores other tables. Each "other table", in turn, contains information about one player nearby. We have already checked that at least one player is present, but there may be more people gathered around, totally not planning a siege, and we don't yet know whether you are there. You blindly assume you would be the first player in the returned list. Unfortunately, the entity detector couldn't care less about that, and your entry could easily be the second or the last one. Or not present at all, if you happened to carelessly abandon your fortress. Our mini-goal is to walk through all the entries of the table (this is called iterating a table) until your entry is found. If after iterating through all items we have yet to found yours, you're not around. So we close the door and activate the alarm. Otherwise, we do the opposite. This is how you do it: local ownerNearby = false for _, entry in ipairs(scan) do if entry.name == owner then ownerNearby = true break end end if ownerNearby then door.open() alarm.deactivate() print("Welcome home!") else door.close() alarm.activate() print("Hello, whoever you are.") end Something isn't right... The program will keep spamming "Welcome home!" if you're in vicinity, which isn't quite courteous. Let's make it greet you only if you weren't around before that, and do likewise for greeting intruders. To do that, we need to remember the previous state of your program: whether there was nobody, an intruder, or you. local component = require("component") local alarm = component.os_alarm local door = component.os_door local entity = component.os_entdetector local owner = "sav" -- insert your nickname here local previousState = "nobody" while true do local scan = entity.scanPlayers(64) if scan and #scan > 0 then local ownerNearby = false for _, entry in ipairs(scan) do if entry.name == owner then ownerNearby = true break end end if ownerNearby and previousState ~= "owner" then door.open() alarm.deactivate() print("Welcome home!") previousState = "owner" elseif not ownerNearby and previousState ~= "intruder" then door.close() alarm.activate() print("Hello, whoever you are.") previousState = "intruder" end else door.close() alarm.deactivate() previousState = "nobody" end os.sleep(2) end Well, this is the whole program. I didn't test it, so any bugs are yours to find and exterminate.
  32. 2 points
    A while ago i made a JVM in Lua with the first goal of running Java on OC, just because i like Java and we all know it's a good programming language. So here's the JVM running a program that fills GPU: Oops, made a typo. Ok at first this might not seem impressive at all, but now you can interact with components using Java! That's an awesome thing for Java-ers like me! Race to first Java OS in OC? Anyone? Here's the (simple) code i used above import lukyt.oc.Component; public class ComponentTest { public static void main(String[] args) { String gpu = Component.getPrimary("gpu"); Component.invoke(gpu, "setBackground", new Object[] {0x2D2D2D}); Component.invoke(gpu, "fill", new Object[] {1, 1, 160, 50, " "}); System.out.println("Filled screen with RGB 0x2D2D2D"); } } Here's GitHub page (to download and use on your favourite OC computer): https://github.com/zenith391/lukyt
  33. 2 points
    How to Write an OpenComputers Operating System This is the kind of guide I wish I had had 9 months ago when I started developing operating systems for OpenComputers. It will walk you through writing a very basic OpenComputers operating system. EDIT: The guide I followed (the only one I found) is here: WARNINGS: -- This post assumes basic knowledge of programming, such as: what a string is, what a table or list is, what a function is, what a variable is, etc. I am NOT attempting to teach you Lua-- see warning #3 -- This operating system is not intended to have many features (nor is it fast!), but more so to teach new programmers. I will try to keep my code well-organized and well-commented, but no guarantees! -- If you're new to Lua, go read the PIL (https://lua.org/pil/1.html), and keep the Lua reference manual (https://lua.org/manual/5.3/manual.html) open in case you need to reference it. (I also recommend having the OpenComputers wiki [https://ocdoc.cil.li] open.) -- Note that the component, unicode, and computer APIs, plus checkArg, are unique to OpenComputers, and that io and package (plus require, loadfile, and dofile) must be defined by the user. -- This OS is structured in a way that is meant to be easy-to-follow, though you can lay your own out however you like. All source code is available at https://github.com/ocawesome101/basic-oc-os under no license in particular. 1. Init.lua init.lua is the file that most BIOSes expect to load. Most operating systems, this one included, simply use init.lua to load their kernel. This is an example of an init.lua file: -- The path to our kernel. Note that it is advisable to use the 'local' keyword in front of your variables unless you want them to be accessible from everywhere. local KERNEL_PATH = "/mini/kern.lua" -- Get the computer's boot address local address = computer.getBootAddress() -- Open the kernel file for reading local handle, err = component.invoke(address, "open", KERNEL_PATH) if not handle then -- The kernel is probably not present! error(err) end -- Read all the data from the kernel file local kernelData = "" repeat local chunk = component.invoke(address, "read", handle, math.huge) kernelData = kernelData .. (chunk or "") -- (chunk or "") protects against errors until not chunk -- End Of File -- Close the kernel file handle component.invoke(address, "close", handle) -- Try to turn the data we read into a function we can call local ok, err = load( kernelData, -- the data (or "chunk") "=" .. KERNEL_PATH, -- what name to use for the loaded chunk, prefixed with an "=" "bt", -- the mode with which to load the chunk. "bt" should be generally fine _G ) if not ok then -- There was probably a syntax error or some such thing error(err) end ok() -- Execute the kernel -- an idle loop in case the kernel exits. Could be replaced with computer.shutdown() while true do computer.pullSignal() end The comments should explain fairly well what is happening. init.lua should be placed in the root of your drive. 2. The Kernel The kernel is the heart of your operating system. In more advanced operating systems, the kernel usually contains some basic hardware management, a scheduler (relatively complex beasts involving coroutines and signal timeouts), and possibly drivers, leaving the rest of system initialization to the init process. For the sake of this tutorial, we will jump straight from a basic kernel to the shell. In my case, the kernel is at /mini/kern.lua, though yours can be almost anywhere. For compatibility's sake, it is usually a good idea to start by defining _OSVERSION like so: _G._OSVERSION = "mini 0.1.0" Next, you should find installed GPU and screen components- at least one of each. local gpu = component.list("gpu")() local screen = component.list("screen")() There are two ways to interact with components: component.invoke and through a proxy. For extended usage, a proxy is generally the better choice, but for one or two operations component.invoke is fine. An example of component.invoke usage: component.invoke( gpu, -- The component address, a string "bind", -- The method you want to invoke. Must be valid, and must be a string. screen -- Any additional arguments are interpreted as parameters ) It is probably a good idea to create proxies for the GPU and boot filesystem, since we're going to be using these things a lot. local gpuProxy = component.proxy(gpu) _G.fs = component.proxy(computer.getBootAddress()) -- computer.getBootAddress() is defined by most BIOSes Optionally, you can set up basic onscreen boot logging. This is especially useful for debugging, and it can give some insight into what your OS is doing when it boots. I set up my logging like this. Note that my code is somewhat over-commented for the sake of this tutorial. local line = 1 -- What line are we on? local width, height = gpuProxy.maxResolution() -- get the maximum resolution of the GPU and screen. These values are the minimum of the two. gpuProxy.setResolution(width, height) -- ensure that the screen resolution is properly set gpuProxy.fill( -- Fill a box on-screen with a single character 1, -- The top-left X coordinate 1, -- The top-left Y coordinate width, -- How wide the box should be height, -- How tall the box should be " " -- The character the box should be made of ) local function log(message) -- checkArg is a very useful function, used for argument checking. checkArg( 1, -- the argument number message, -- the argument itself "string" -- one or more types that are allowed for the argument, in the form of separate strings. ) -- Set the line at gpuProxy.set( -- Set a line (or part of a line) onscreen to a string 1, -- The X coordinate of the string line, -- The Y coordinate of the string message -- The string ) if line == height then -- We can't go down or we'll be off the screen, so scroll down a line gpuProxy.copy( -- Copy one screen area to another 1, -- The top-left X coordinate 1, -- The top-left Y coordinate width, -- The width height, -- The height 0, -- The relative X to copy to -1 -- The relative Y to copy to ) gpuProxy.fill(1, height, width, 1, " ") else line = line + 1 -- Move one line down end end -- Crash the system in a slightly prettier fashion. Not necessary, but nice to have. local function crash(reason) checkArg(1, reason, "string", "nil") -- This is an example of checkArg's ability to check multiple types -- Here, reason is already local; there is no need to specify it so reason = reason or "No reason given" log("==== crash " .. os.date() .. " ====") -- Log the crash header, ex. "==== crash 24/04/20 18:52:34 ====" log("crash reason: " .. reason) -- Log the crash reason. ".." is Lua's string concatenation operator. local traceback = debug.traceback() -- Tracebacks are usually useful for debugging traceback = traceback:gsub("\t", " ") -- Replace the tab character (not printable) with spaces (printable) for line in traceback:gmatch("[^\n]+") --[[ :gmatch("[^\n]+") splits the string on the \n (newline) character using Lua's basic regular expressions ]] do log(line) end log("==== end crash message ====") while true do -- Freeze the system computer.pullSignal() end end For sanity's sake (and ease-of-use) you should define loadfile(), dofile(), and require(). If you set up module caching in require, you can do some neat things that otherwise would be difficult, such as library persistence across programs. loadfile() is probably the most complex of the three: function _G.loadfile(file, mode, env) checkArg(1, file, "string") checkArg(2, mode, "string", "nil") checkArg(3, env, "table", "nil") -- Make sure mode and env are set mode = mode or "bt" env = env or _G -- env can be used for sandboxing. Quite useful. local handle, err = fs.open(file, "r") if not handle then return nil, err end local data = "" repeat local fileChunk = fs.read(handle, math.huge) data = data .. (fileChunk or "") until not fileChunk fs.close(handle) -- Always close your file handles, kids return load(data, "=" .. file, mode, env) end Then dofile: function _G.dofile(file) checkArg(1, file, "string") local ok, err = loadfile(file) if not ok then return nil, err end return ok() end Basic library caching can be setup very quickly with: local loaded = { ["gpu"] = gpuProxy } -- Libraries that have already been loaded Next, you should implement some sort of require() function. Ideally we'd do this with a fully fledged package library, but that's much more complex. First, you'll need paths of some kind to search. I did mine this way: local libPaths = { -- The path(s) to search for libraries "/mini/lib/?.lua", "/ext/lib/?.lua" } The standard Lua package.path is "/usr/share/lua/5.3/?.lua;/usr/share/lua/5.3/?/init.lua;/usr/lib/lua/5.3/?.lua;/usr/lib/lua/5.3/?/init.lua;./?.lua;./?/init.lua" but the above is considerably easier to parse. To disable package caching, useful for development, you can comment out the lines suffixed with "--". function _G.require(lib) checkArg(1, lib, "string") if loaded[lib] then -- return loaded[lib] -- else -- -- It wasn't already loaded, so search all the paths for i=1, #libPaths, 1 do component.proxy(component.list("sandbox")()).log(libPaths[i]:gsub("%?", lib)) if fs.exists( libPaths[i] -- The current path :gsub( -- Replace a character or characters in a string with another string "%?", -- The string to replace. "%" is necessary because string.gsub, string.gmatch, and string.match interpret "?", along with a few other patterns, as a form of regex (DuckDuckGo regular expressions if you don't know what regex is). lib -- The string with which to replace "?" ) ) then local ok, err = dofile(string.gsub(libPaths[i], "%?", lib)) -- string.gsub("stringToGSUB", ...) is the same as ("stringToGSUB"):gsub(...) if not ok then error(err) end loaded[lib] = ok -- return ok end end end -- end Once this is all done, I load my shell with a simple while true do local ok, err = dofile("/mini/shell.lua") -- Run the shell if not ok then crash(err) end end Note that mine is encased in a while loop so that if the shell exits it will restart. We aren't done yet though, as we still need to program the shell. 3. The shell For simplicity's sake, my shell is just a basic Lua interpreter. It doesn't seem to function properly in ocvm, unfortunately (pcall results are strange, I'll have to test in-game) but here it is, in all its glory: _G.term = require("term") _G.gpu = require("gpu") -- This is where the loaded = { ["gpu"] = gpu } line comes in term.clear() function _G.print(...) local args = {...} for k, v in pairs(args) do term.write(tostring(v) .. " ") end term.write("\n") end local currentDirectory = "/" -- self explanatory local function drawPrompt() gpu.setForeground(0x00FF00) -- Colors are stored as 24-bit hexadecimal values. (Look up "hexadecimal color"). 0x00FF00 is bright green. term.write("\n" .. currentDirectory .. " > ") gpu.setForeground(0xFFFFFF) end local function printError(err) gpu.setForeground(0xFF0000) term.write(err .. "\n") gpu.setForeground(0xFFFFFF) end local function execute(command) local ok, err = load(command, "=lua") if not ok then ok, err = load("=" .. command, "=lua") if not ok then return nil, err end end local result = {pcall(ok)} -- pcall, or protected call, captures errors. Very useful function. if not result[1] and result[2] then return printError(result[2]) end for i=#result, 1, -1 do print(result[i]) end end while true do drawPrompt() local command = term.read() if command ~= "\n" then execute(command) end end What is this shell doing? First, it defines a few utility functions (print(), drawPrompt, printError, and execute), and then it runs the shell's main loop. But wait! What about the top line? Where is the term API? It's in /mini/lib/term. I implemented term.getCursorPosition, term.setCursorPosition, term.scroll, term.clear, term.write, and term.read, but you can implement more fairly easily. Internally, there are two functions (showCursor and hideCursor) that I call after and before every operation, respectively. For example, when you call term.setCursorPosition(2, 2), the term API executes this code: function term.setCursorPosition(newX, newY) checkArg(1, newX, "number") checkArg(2, newY, "number") hideCursor() cursorX, cursorY = newX, newY showCursor() end cursorX and cursorY, as well as width and height, are used internally for purposes you can probably guess based on their names. If you need it, here's my term.read function (text input is always particularly tricky to get right): -- Fairly basic text imput function function term.read() local read = "" local enter = 13 local backspace = 8 local startX, startY = term.getCursorPosition() local function redraw() term.setCursorPosition(startX, startY) term.write(read) --.. " ") -- the extra space ensures that chars are properly deleted end while true do redraw() local signal, _, charID, keycode = computer.pullSignal() -- signal is the signal ID, charID is the ASCII code of the pressed character, and keycode is the physical keyboard code. Note that these are keypress-specific!! if signal == "key_down" then -- A key has been pressed if charID > 31 and charID < 127 then -- If the character is printable, i.e. 0-9, a-z, A-Z, `~!@#$%^&*()_+-=[]{}\|;':",./<>? read = read .. string.char(charID) elseif charID == backspace then -- The character is backspace read = read:sub(1, -2) -- Remove a character from the end of our read string elseif charID == enter then -- my god Kate's syntax detection is crap read = read .. "\n" redraw() return read end end end end That should be all! Feel free to comment if you need help (be sure to provide error messages and the relevant bits of your code) and I'll do my best to respond. My results with this code (I can enter Lua statements and they will be run): Next Steps: -- Expand on this OS with a more advanced shell, io and package libraries, and the like -- Write your own OS with a task scheduler using coroutines -- Be sure you give events to all processes! My first scheduler very much did not do that.
  34. 2 points
    bad at vijya

    OpenSolidState

    OpenSolidState for Minecraft 1.12.2 ____________________________________________________ Source Code and builds can be found on Github. Note: Requires Forgelin. General Purpose (E)EPROMs? Have you ever wanted fast storage? How about wanting to boot PsychOS 2 on a uC? Well, now you can! There are two main variants: The card and the drive. The Card! The Drive! Tiers: Tier 1 - Manually erased EPROM, erased with the assembler. 64KiB Tier 2 - Electronically erased! Still 64KiB Tier 3 - Bigger EEPROM! 128KiB! But how do I craft them? Just use JEI, trust me. What else is included? A utility floppy and ROMFS boot EEPROM are included with the mod! Feel free to ask more questions! i need to make docs
  35. 2 points
    A while back, I've quietly released an unofficial, experimental OpenComputers fork called OC-Staging, available here. The key features as of writing include: Optimized GPU rendering code, providing up to 2x better performance (in terms of frame rendering time), LuaJ and JNLua bugfixes and updates, Native Lua performance improvements, Lua 5.4 support! (currently on lua-5.4.0-beta) This is the feedback thread for this fork, as input is sought before merging the changes back into OpenComputers due to their potentially invasive nature (for bug reports, please use the issue tracker).
  36. 2 points
    Overview Hello there. Some of you may remember KLang. I decided that I should you know, actually work on it. Therefore, I present Triton/TritonLang. Triton is the continuation of KLang, a C++-styled programming language that compiles to Lua. I have no ETA on when it will be done as of the moment, but it is work in progress and I would possibly like to get feedback on my current project status. Hello, world! [Pseudocode] #include <io> int main() { io::info("Hello, world!"); return 0; } Advantages to Lua Headers/easily include libraries Statically and dynamically compiled libraries for programs C++-style syntax and easier OOP Helpful Links WIP Documentation GitHub Repository
  37. 2 points
    bad at vijya

    Zorya BIOS and Bootloader

    Zorya BIOS Zorya BIOS is an extendable and configurable BIOS and bootloader, capable of booting any OS with the right extensions. It's similar to GRUB. (sorry in advance for bios.lua) All you need to install the BIOS is to flash bios.lua to a blank EEPROM, insert a blank floppy, then reboot. Note: This has only been tested on Tier 3 hardware and Lua 5.3. requires an Internet card. Github repo PRs are welcome! Future plans: Ability to load from non-managed disks (like disks formatted with msdosfs, etc) Make it easier to extend Clean up code! Ability to edit options from bootloader Automatically load an OS after n seconds
  38. 2 points
    Update 3.0.0: I've added secondary screens to make your control room cooler.
  39. 2 points
    sence i saw igor Timofeev's mineos i was thinking if it was posible to get those static windows to move and infact there is: welcome to the first showcase of the (really un-creative named) tacti OS: as you can see it figtures moveable, sizeable, and interactive windows infact all programs running in the OS will be windowed! useing my easy-to-use windowLib and windowed-program-api i'll happyly resive any feedback (download link avalable in the below posts) (also its gonna happen anyway so come with those grammer currections poeple, i can take it) i hope you guys will like my project -thanks
  40. 2 points
    And just to push it over the top into the rediculous area I've doubled it again to 256! That should be enough for forever. (I even had a lot of trouble coming up with so many for testing)
  41. 2 points
    payonel

    No Bootable Medium Found

    that is a ComputerCraft disk drive, not the OpenComputers disk drive
  42. 2 points
  43. 2 points
    This is a simple door opening script that requires a password to be entered. That being said it took me a ridiculously long time to work out all the bugs. It works by taking an input from one computer and sending it to another to check if the password is correct. This makes it much harder to simply look at the file to check what the password is. It also now has the ability to automatically encrypt your password if you have a T1 data card along with the server asking you to input a password on the first run. These ideas came from the user RandomRedMage Requirements: At least 2 computers with basic parts 2 Network cards or Wireless Network cards Redstone T1 card Data card T1 (optional) The pastebin id for the server version is 8Y2y9xH3 The pastebin id for the client version is F5P5V05P Source code for both here Currently it needs to be placed into /home/bin and named door.lua to work but editing the 4 spots where os.execute is called will let you place it wherever with any name Also you need to enter the password twice the first time it is booted in order to have both computers recognize each other this can be circumvented via hard coding the address of the modem of each system into the other or adding a file into each /home/bin called MAC.psd with the modem address of the other. It is currently set up for only one computer but it could easily made to work for multiple by making the address var into a table and having a loop check thru them though that may slowdown the process.
  44. 2 points
    I haven't been here in a long while, mostly because life, the universe, and everything has been getting in the way of fun. Also, I'm usually an eternal lurker, but hey today I have a small contribution, As I have been playing I wanted a gui interface to easily turn on and off the different nanomachine flags. So I built a small application to do it. Right now it is super basic, but I hope to flesh it out a bit more and give it proper displays ect, so I dont have to do things as janky as I did here. Long story short, I'm bad at lua/coding/scripting in general, so its a little hamfisted and could prolly be streamlined a lot, As some basic prerequisites, it needs a computer or tablet with a teir 2 graphics card, and a wireless card. I used Dustpuppies gui api found here: It was really helpful, and made setting up an interface really simple. Screenshot below~ Pastebinlink: https://pastebin.com/wrxi0726 Buttons that say on, turn flags on, buttons that say off turn flags off. super simple nonsense. arguments~ you can launch the file with the argument '-s' and this will skip a 'loading' screen I coded into it. The loading screen, is just a visual representation of the program turn off all nanomachine flags one by one. since nanomachines will only respond to commands once every second or so. I did this as I am still learning and figureing things out with network messages, and sending is easier than receiving for me, lol and telling the nanos to turn everything off was easier than asking the nanos whats turned on, and setting the buttons up to match it at launch. Mainly because I am dense, and it's going to take a little time to work things out and hammer it into my mind how to do this. Thanks for taking a look at my nonsense. If you have any suggestions, or contributions, please, speak up. D: seriously I wont learn exactly how terrible I am at this without your help, and in turn wont get any better. I made this because I wanted to, and the only nanomachine control app I was able to find was just a text based type thigns application. [though that application has been helpful in setting this up and will likely be helpful in continuing work on this program. As I believe every nanomachine function is in use by it. https://www.youtube.com/watch?v=gl3zGcTh67w that's the program. I picked apart to learn how to do this and stuff. D
  45. 2 points
    ZeroNoRyouki

    Big Reactors Grid Control

    Hi, I've just posted and updated version of ER on Curse (It's under review right now). All the Callbacks are back to the old-direct-call-we-dont-care-about-threads-because-who-knows way of the original code. You must break and replace all your computer ports to see this in action Z
  46. 2 points
    payonel

    Big Reactors Grid Control

    Read, "where the call takes at least one server tick" Here: https://github.com/MightyPirates/OpenComputers/blob/f5c19e9e7e0006d3403c7bf0b44dfb970cee8a2f/src/main/java/li/cil/oc/api/machine/Callback.java#L43-L59
  47. 2 points
    ZeroNoRyouki

    Big Reactors Grid Control

    Hi there! So, I've run the "test" program in my 1.10.2 devenv and got the same bunch of 1s. I then changed getEnergyStored() to always return a fixed values without querying the reactor and tested again: same result. This is good, as it's not the reactor code that it's slowing thigs down What I basically have, code wise, is an OC'Enviroment with a bunch of @Callbacks (getEnergyStored, getFuelAmount, etc). DE also implement an Enviroment but it use a string lookup (from ManagedPeripheral) to call the methods. If OC is using reflection to find the correct method on every method invocation we could have and explanation of the delay. I'll have to look around a bit more in OC code Z
  48. 2 points
    I would like a Special Thinger™ as well. I have started and kept up a series of tutorials for OpenComputers, adding sorely needed documentation. Been active in finding bugs and suggesting features. I regularly check Reddit's FeedTheBeast subreddit and include information and assistance about OpenComputers where relevent. Do the same on these forums. Also really proud of my CompressCobble program. IGN is StoneNomad, requested color is 205 197 191: seashell 3 according to http://cloford.com/resources/colours/500col.htm
  49. 2 points
    I want a Special Thinger ™! Author of OpenPrinter, and OpenLights with 600+ and 200+ downloads respectively. http://www.curse.com/mc-mods/minecraft/225127-openprinter and http://minecraft.curseforge.com/mc-mods/225225-openlights, I also contributed a bit to the IRC program OpenPrinter adds Text printers and scanners to the game, and OpenLights adds a colorable light block. I guess for color 255 0 0 (assuming that's Red IGN is MichiyoRavencroft Thanks, looking forward to my Special Thinger ™
  50. 2 points
    Kodos

    Hologram Editor

    With the addition of 3D Printers, I'd love to see this expanded upon, and used as a 3D Print preview and creation system
  • Newsletter

    Want to keep up to date with all our latest news and information?
    Sign Up
×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use and Privacy Policy.