Первый Гайд:
Собрать планшет в сборщике необходимо компоненты:
1 - Корпус планшета (можно взять креатив)
2 - Интернет-карта
3 - Клавиатура (поместится в 1 слот)
4 - Оперативный память 3-2 уровня
5 - eeprom (нужно чтобы прошито MineOS EFI)
6 - память (нужно чтобы установлен MineOS)
7 - добавить 8 ёмкостей

Второй Гайд:
вы должны собрать компьютер и ввести install и потом pastebin run PDE3eVsL

Третий Гайд:
вы должны поставить mineOS если до конца установился переносите в сборщике память и всё можно запустить операционную систему mineOS
 

Для начала нам нужно поставить радио. Затем поставить динамик рядом с радио и соединить. Так возникает вопрос, как их соединить?

Все просто! Берем радио тюнер из OpenFM и сначала нажимаем пкм по динамику а затем по радио, готово!

Затем возник еще один вопрос, а как нам транслировать наши аудио файлы? Можно конечно через гугл диск, но так как его могут заблокировать, будем использовать более легкую и надежную схему: для начала перейдем на сайт: https://fm.hinja.xyz в нем нам надо нажать "Выбрать файл"

При загрузке нам надо соблюдать несколько правил:

1. Формат который поддерживает OpenFM (это MPEG) но вот вопрос как нам сделать mp3 в mpeg? Просто замените расширение или воспользуйтесь конвертером!

2. Файл не должен содержать пробелов и русских букв! (пример: marshmallow_alone.mpeg)

Далее после того как мы все загрузили нам надо получить ссылку, как это сделать? Когда вы выбрали файл и нажали загрузить у вас в левом верхнем углу будет ссылка то есть нас интересует только ссылка, она там одна (смотрите внимательнее)

Супер! Когда у нас есть ссылка мы можем вставить её в поле StreamURL и нажать кнопку плей и готово!!! Спасибо за прочтение

И так. Для себя "легко и удобно" это нажать на пару кнопок и не париться.

Для воспроизведения музыки в OpenFM нужна прямая ссылка на музыку или радио, ее не так легко бывает найти, а еще может захотеться, что бы играла любая своя музыка.

Всё что нужно сделать, это лишь скачать программу, которую я сделал, и половина уже готова.
В Minecraft заходим в блок Радио и вписываем в "StreamURL" "http://localhost"(если вы играете с другом при помощи VPN туннеля(Hamachi, RadminVPN...), то впишите "http://"+ IPv4 хоста) и ждем пока буду выполнены следующие действия уже в программе.

Если всё правильно сделать, то в браузере будет аналогичный результат.

Программа+- проста в использовании:

1. Открываем программу
2. Нажимаем на кнопку если написано "Not Hosting"(кнопка отображает значение работы сервера).
3. В нажимаем на кнопку "Выбрать файл" и выбираем музыку(не работает с видео, и форматами отличных от mp3, ogg и wav), или вставляем путь в пустое окно текста.

Теперь о изъянах:

1. Нельзя поставить на паузу - мод OpenFM был ориентирован на постоянную подачу аудио(радио трансляция). Вместо этого музыка будет начинаться сначала. Также расширение в среде, где которой я делал программу, не позволяет(задумано и без костылей) вести прямой эфир.
2. Файл отправляется, сразу после захода на сервер. Если вы подключились и начали слушать музыку, то можете не беспокоиться о том, включён ли хост.
3. Может случиться баг, когда вы всё правильно сделали, а радио не хочет запускаться. В таком случае можете заново установить этот блок или перезайдите в мир.

Программу можно будет скачать по ссылке ниже(если у ваш антивирус найдёт там вирусы, то или у вас липовый антивирус, либо он очень старый, либо это связано с историей развития движка(в суме ему около 20 лет) и антивирусы не правильно распознают встроенные функции программы)

Программа будет развиваться если будут предложения, для ее улучшения.

Программа:https://drive.google.com/open?id=16q7O0Cdi35QbKNHSISpbUDWsW3kCNQl8
Исходник(написан на Clickteam Fusion Developer R291.6):https://drive.google.com/open?id=1_UtEnlMuPWhlCCFiFt-2NDsscEF3oTep

Изменено: планирую сделать программу в OpenComputers, для общения с локальным сайтом(будет возможно сделать внутриигровой выбор музыки с настоящего компьютера)

Немного теории

• enable/disable. Соответственно включают/выключают скрипт. Все включенные скрипты получат команду start при запуске компьютера.
• restart если есть start и stop. Перезапускает скрипт, то есть поочередно запускает stop и start.

Каждый скрипт можно конфигурировать. Конфиг находится в /etc/rc.cfg.
Формат файла прост:

<имя скрипта> = <конфиг: все что угодно, таблица, текст, число>

По сути это обычный луа-файл, все глобальные значения из которого считаются полями.

Каждый скрипт может получить доступ к своему конфигу. Конфиг записывается в переменную args.

С теорией покончено, приступим к практике!

Практика

Я предлагаю написать простой эхо-сервер. Он будет слушать определенный порт (из конфига), и отвечать на любое сообщение эхом.

Начнем!

Создадим файл /etc/rc,d/echo.lua, и начнем писать в нем код.

Нам понадобятся некоторые переменные

-- нам понадобятся библиотека event
-- что бы установить свой обработчик событий
local event = require("event")

-- еще нам нужна библиотека computer
-- что бы подключить компонент `modem`
local component = require("component")

-- будем считать количество ответов
-- зачем? для диванных аналитиков конечно!
local count = 0

-- будем хранить текущее положение
-- что б никто не запустил случайно сервер два раза
local started = false

-- сюда запишем прокси модема, когда убедимся что он есть
local modem

-- а сюда запишем рабочий порт
local port

Создадим обработчик события modem_message. Он будет вызываться при каждом сообщении по сетевой карте.

-- функция ниже будет запускаться
-- при каждом сообщении по сетевой плате
local function onModemMessage(_, _, snd, prt, _, ...)
  -- `_` в нашем понимании - неиспользуемый аргумент

  -- если порт сообщения не совпадает с портом
  -- из конфига, выходим
  print(prt)
  if prt ~= port then
    return
  end

  -- добавим еденицу к счетчику
  count = count + 1

  -- здесь мы уверены, что modem существует
  -- так как обработчик поставится только если у нас есть модем
  modem.send(snd, prt, ...)
  --         /     |    \
  -- получатель, порт, данные

  -- просто напросто пересылаем отправителю то что он
  -- отправил нам =)
end

Теперь мы добавим команду start, которая запустит наш сервер.

-- функция ниже глобальная, `local` нет.
-- потому _rc_ ее будет смело считать командой
-- а команда эта будет запускать наш сервер
function start()
  -- мы должны проверить, есть ли у нашего сервера
  -- сетевая карта
  if not component.isAvailable("modem") then
    -- если ее нет, мы выводим ошибку и выходим
    io.stderr:write("Сетевая карта не найдена!")
    return
  end

  -- еще нам нужно проверить, выключены ли мы
  -- если это не так, снова ошибка
  if started then
    io.stderr:write("Сервер уже запущен!")
    return
  end

  count = 0   -- сбросим счетчик
  started = true   -- теперь мы знаем, что с этого момента
                   -- сервер включен.

  port = args or 666
  -- args это переменная, в которую _rc_ запишет данные из конфига
  -- конфиг находится в /etc/rc.cfg
  -- но если в конфиге порт не настроен, используем дефолтный

  modem = component.modem
  -- мы проверили, что модем существует,
  -- поэтому смело его подключаем

  -- откроем порт
  modem.open(port)

  -- нам нужно сделать так, что бы все сообщения
  -- по сетевой карте обслуживались нашей функцией
  event.listen("modem_message", onModemMessage)
  -- ну а теперь мы точно включились!
end

Куда без команды stop? Добавим ее!

-- эта функция тоже глобальная, поэтому считаем ее командой
-- эта команда остановит сервер
function stop()
  -- мы должны проверить, включен ли вообще сервер
  -- если он не включен, какой толк его выключать, верно?
  if not started then
    -- если он не включен, выводим ошибку и выходим
    io.stderr:write("Сервер уже выключен!")
    return
  end

  count = 0   -- опять же сбрасываем счетчик
  started = false   -- запоминаем, что теперь
                    -- сервер выключен

  -- теперь нам нужно по-настоящему выключить сервер
  event.ignore("modem_message", onModemMessage)
  -- все! с этого момента сервер выключен, и не принимает сообщение
end

Еще самая малость, добавим команду printCount, которая будет отображать количество полученных сообщений.

-- и это тоже команда, думаю вы понимаете
-- а эта команда напишет количество отправленных сообщений
function printCount()
  -- выводить информацию будем только если сервер не запущен
  -- поэтому выведем ошибку, если он не включен
  if not started then
    io.stderr:write("Сервер выключен!")
    return
  end

  print(count)   -- пишем количество подключений
                 -- диванные аналитики ликуют!
end

Ну вот и все, программа сделана, диванные аналитики ликуют, инженеры недоумевают.

Полный код:

-- нам понадобятся библиотека event
-- что бы установить свой обработчик событий
local event = require("event")

-- еще нам нужна библиотека computer
-- что бы подключить компонент `modem`
local component = require("component")

-- будем считать количество ответов
-- зачем? для диванных аналитиков конечно!
local count = 0

-- будем хранить текущее положение
-- что б никто не запустил случайно сервер два раза
local started = false

-- сюда запишем прокси модема, когда убедимся что он есть
local modem

-- а сюда запишем рабочий порт
local port

-- функция ниже будет запускаться
local function onModemMessage(_, _, snd, prt, _, ...)
  -- `_` в нашем понимании - неиспользуемый аргумент

  -- если порт сообщения не совпадает с портом
  -- из конфига, выходим
  print(prt)
  if prt ~= port then
    return
  end

  -- добавим еденицу к счетчику
  count = count + 1

  -- здесь мы уверены, что modem существует
  -- так как обработчик поставится только если у нас есть модем
  modem.send(snd, prt, ...)
  --         /     |    \
  -- получатель, порт, данные

  -- просто напросто пересылаем отправителю то что он
  -- отправил нам =)
end

-- функция ниже глобальная, `local` нет.
-- потому _rc_ ее будет смело считать командой
-- а команда эта будет запускать наш сервер
function start()
  -- мы должны проверить, есть ли у нашего сервера
  -- сетевая карта
  if not component.isAvailable("modem") then
    -- если ее нет, мы выводим ошибку и выходим
    io.stderr:write("Сетевая карта не найдена!")
    return
  end

  -- еще нам нужно проверить, выключены ли мы
  -- если это не так, снова ошибка
  if started then
    io.stderr:write("Сервер уже запущен!")
    return
  end

  count = 0   -- сбросим счетчик
  started = true   -- теперь мы знаем, что с этого момента
                   -- сервер включен.

  port = args or 666
  -- args это переменная, в которую _rc_ запишет данные из конфига
  -- конфиг находится в /etc/rc.cfg
  -- но если в конфиге порт не настроен, используем дефолтный

  modem = component.modem
  -- мы проверили, что модем существует,
  -- поэтому смело его подключаем

  -- откроем порт
  modem.open(port)

  -- нам нужно сделать так, что бы все сообщения
  -- по сетевой карте обслуживались нашей функцией
  event.listen("modem_message", onModemMessage)
  -- ну а теперь мы точно включились!
end

-- эта функция тоже глобальная, поэтому считаем ее командой
-- эта команда остановит сервер
function stop()
  -- мы должны проверить, включен ли вообще сервер
  -- если он не включен, какой толк его выключать, верно?
  if not started then
    -- если он не включен, выводим ошибку и выходим
    io.stderr:write("Сервер уже выключен!")
    return
  end

  count = 0   -- опять же сбрасываем счетчик
  started = false   -- запоминаем, что теперь
                    -- сервер выключен

  -- теперь нам нужно по-настоящему выключить сервер
  event.ignore("modem_message", onModemMessage)
  -- все! с этого момента сервер выключен, и не принимает сообщение
end

-- и это тоже команда, думаю вы понимаете
-- а эта команда напишет количество отправленных сообщений
function printCount()
  -- выводить информацию будем только если сервер не запущен
  -- поэтому выведем ошибку, если он не включен
  if not started then
    io.stderr:write("Сервер выключен!")
    return
  end

  print(count)   -- пишем количество подключений
                 -- диванные аналитики ликуют!
end

Время QA!

Симулируем Васю Пупкина...

А вот уже на другом компьютере отправлено сообщение на работающий сервер.

Счетчик тоже работает.

Установим значение в конфиге.

Проверим...

Все работает, инженеры ликуют! 

Такую систему очень удобно использовать для всяческих серверов. Сервер может спокойно работать в фоне, а в главном потоке спокойно можно запускать консоль сервера, интерпретатор луа,  rm -rf /  ...

Enjoy!

• Github аккаунт
• Хостинг, на котором можно разместить серверную часть.

И если с первым всё предельно понятно, то со вторым возникает вопрс: А где его, собственно, взять? Вариантов много. Можно арендовать VPS, поднять сервер на домашнем компьютере или Raspberry Pi, можно воспользоваться услугами таких сайтов как Heroku или PythonAnywhere. Последний вариант примечателен тем, что он полностью бесплатный. И так, какой из сайтов выбрать? PythonAnywhere имеет более ограниченный функционал, по сравнению с Heroku. Но, при этом он намного легче в настройке и эксплуатации, так что остановимся на нём. Далее по пунктам:

1)Заливаем программу на гитхаб.

2)Переходим по ссылке, и создаём токен. Ставим только одну галочку:

После создания запоминаем копируем токен, он нам дальше пригодится. Обращаю внимание, что токен нужно держать в секрете.

3) На этом этапе нам нужен хостинг. Я рассмотрю пример с www.pythonanywhere.com . Идём на сайт, регистрируем аккаунт и создаём Flask приложение. В этом нет ничего сложного, если знать английский. Находим файл flask_app.py, и вставляем в него следующее содержимое:

from flask import Flask
from flask import request
import requests
import json

def request_url(url, result):
    r = requests.get(url)
    j = json.loads(r.text)
    for x in j:
        if x["type"] == "file":
            result = result + "\"" + x["path"] + "\","
        else:
            result = request_url(x["url"],result)
    return result

app = Flask(__name__)

#@app.route('/',methods=['POST'])
def main():
    uname = ""# Сюда нужно прописать логин аккаунта Github
    token = ""# А сюда полученный токен
    if uname != request.args["owner"]:
        return "{}"
    result = request_url("https://"+uname+":"+token+"@api.github.com/repos/"+request.args["owner"]+"/"+request.args["repo"]+"/contents"+request.args["path"]+"?ref="+request.args["ref"],"{")
    result = result + "}"
    return result

app.add_url_rule("/", "main", main,methods=['GET'])

Заполняем поля uname и token, и можно двигаться дальше.

4) На своём компьютере создаём Lua файл, и вставляем в него:

local internet = require("internet")
local fs = require("filesystem")
local shell = require("shell")
local ser = require("serialization")

local host = ""--Хост, на котором расположена серверная часть
local owner = ""--Логин аккаунта Github
local repo = ""--Название репозитория
local ref = "master"--Название ветки
local path = "/"--Путь к папке, из которой скачивать файлы
local deploy_to = "/"--Куда скачивать файлы

function request(url)
  local data = ""
  local result, response = pcall(internet.request, url)
  if result then
    local result = pcall(function()
      for chunk in response do
        data = data .. chunk
      end
    end)
  end
  return data  
end

files = ser.unserialize(request("http://"..host.."/?owner="..owner.."&repo="..repo.."&path="..path.."&ref="..ref))

for _,v in pairs(files) do
  local pth = deploy_to..v
  if not fs.exists(pth:match(".*/")) then fs.makeDirectory(pth:match(".*/")) end
  shell.execute("wget -f ".."https://raw.githubusercontent.com/"..owner.."/"..repo.."/"..ref.."/"..v.." "..pth)
end

Заполняем поля, и готово.

Вместо вступления:

Я не считаю C-подобный синтаксис лучше синтаксиса lua и не буду заставлять вас переписывать все ваши программы на TypeScript! Я просто хочу поделится с вами альтернативой и рассказать про ее преимущества и недостатки.

# Что такое TypeScript?

TypeScript — язык программирования, представленный Microsoft в 2012 году и позиционируемый как средство разработки веб-приложений. Он создан для расширения JavaScript и он компилируется в JavaScript, но также существует инструмент для преобразования TypeScript кода в Lua. Вам может показаться, что этот транслятор крайне ограничен, но, поверьте мне, его возможности впечатляют.

# Почему его стоит попробовать?

Я сначала продемонстрирую некоторые возможности TypeScript графически, а потом подробно расскажу про установку и настройку необходимых инструментов. Я покажу вам далеко не все возможности TypeScript, а только самые основные и интересные.

Из-за большого размера контент каждого раздела будет скрыт под спойлер.

1. Статический анализ

2. Автодополнение

3. ООП

class Player {
    username: string;

    constructor(username: string) {
        this.username = username;
    }

    greet() {
        print("Привет, " + this.username + "!");
    }
}

let alex = new Player("alex");
alex.greet(); // Привет, Alex!

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
Player = {}
Player.name = "Player"
Player.__index = Player
Player.prototype = {}
Player.prototype.__index = Player.prototype
Player.prototype.constructor = Player
function Player.new(...)
    local self = setmetatable({}, Player.prototype)
    self:____constructor(...)
    return self
end
function Player.prototype.____constructor(self, username)
    self.username = username
end
function Player.prototype.greet(self)
    print("Привет, " .. tostring(self.username) .. "!")
end
local alex = Player.new("alex")
alex:greet()

class Player {
    username: string;

    constructor(username: string) {
        this.username = username;
    }
}

class Alex extends Player {
    constructor() {
        super("Alex");
    }
}

let alex = new Alex();
print(alex.username); // Alex

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
Player = {}
Player.name = "Player"
Player.__index = Player
Player.prototype = {}
Player.prototype.__index = Player.prototype
Player.prototype.constructor = Player
function Player.new(...)
    local self = setmetatable({}, Player.prototype)
    self:____constructor(...)
    return self
end
function Player.prototype.____constructor(self, username)
    self.username = username
end
Alex = {}
Alex.name = "Alex"
Alex.__index = Alex
Alex.prototype = {}
Alex.prototype.__index = Alex.prototype
Alex.prototype.constructor = Alex
Alex.____super = Player
setmetatable(Alex, Alex.____super)
setmetatable(Alex.prototype, Alex.____super.prototype)
function Alex.new(...)
    local self = setmetatable({}, Alex.prototype)
    self:____constructor(...)
    return self
end
function Alex.prototype.____constructor(self)
    Player.prototype.____constructor(self, "Alex")
end
local alex = Alex.new()
print(alex.username)

4. Стандартная библиотека и возможности языка

const items = [1, 2, 3, 4, 5];

items.push(6);

const result = items
    .filter(x => x % 2 == 0)
    .map(x => x ** 2)
    .join(", ");

print(result); // 4, 16, 36

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
-- Lua Library inline imports
function __TS__ArrayPush(arr, ...)
    local items = ({...})
    for ____, item in ipairs(items) do
        arr[#arr + 1] = item
    end
    return #arr
end

function __TS__ArrayFilter(arr, callbackfn)
    local result = {}
    do
        local i = 0
        while i < #arr do
            if callbackfn(_G, arr[i + 1], i, arr) then
                result[#result + 1] = arr[i + 1]
            end
            i = i + 1
        end
    end
    return result
end

function __TS__ArrayMap(arr, callbackfn)
    local newArray = {}
    do
        local i = 0
        while i < #arr do
            newArray[i + 1] = callbackfn(_G, arr[i + 1], i, arr)
            i = i + 1
        end
    end
    return newArray
end

local items = {
    1,
    2,
    3,
    4,
    5,
}
__TS__ArrayPush(items, 6)
local result = table.concat(__TS__ArrayMap(__TS__ArrayFilter(items, function(____, x) return x % 2 == 0 end), function(____, x) return x ^ 2 end), ", ")
print(result)

// main.ts
import { myFunction } from "./myLibrary";

myFunction();

// myLibrary.ts
export function myFunction() {
    print("Hi from myLibrary");
}

-- main.lua
--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
local ____exports = {}
local ____myLibrary = require("myLibrary")
local myFunction = ____myLibrary.myFunction
myFunction(nil)
return ____exports

-- myLibrary.lua
--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
local ____exports = {}
function ____exports.myFunction(self)
    print("Hi from myLibrary")
end
return ____exports

const text = `2 + 2 = ${2 + 2}`;
print(text); // 2 + 2 = 4

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
local text = "2 + 2 = " .. tostring(2 + 2)
print(text)

# Как это работает?

Конечно же все не так просто. Компилятор просто так не узнает типы методов и полей объектов, с которыми мы будем работать. Для того, чтобы описать наше окружение необходимо написать так называемые файлы декларации или тайпинги. Хочу сразу вас обрадовать - это не ваша задача. Существует репозиторий с такими декларациями, в котором, на данный момент, существуют типы для большинства API и компонентов OpenOS и библиотеки GUI.

От вас требуется только установить все необходимые инструменты и правильно их настроить.

# Установка

Редактор кода

Вы можете использовать любой редактор кода с поддержкой TypeScript. Я рекомендую VSCode, который поддерживает его из коробки.

NodeJS

Он необходим нам для установки необходимых пакетов (он поставляется с пакетным менеджером npm) и для запуска транспилера. Вы можете скачать последнюю стабильную версию с официального сайта.

Использование плагина для VSCode (рекомендуется):

Создание проекта вручную:

{
    "compilerOptions": {
        "target": "esnext",
        "outDir": "dist",
        "module": "commonjs",
        "lib": ["esnext"],
        "strict": true,
        "moduleResolution": "node",
        "rootDir": "src",
        "types": ["lua-types/jit", "@opct/openos"]
    },
    "tstl": {
        "luaTarget": "JIT"
    }
}

import * as component from "component";
import { front } from "sides";

component.redstone.setOutput(front, 1);

# Создание ссылки через терминал
# linux / macos
ln -s /path/to/disk/home dist

# windows (cmd)
mklink /j dist C:\path\to\disk\home

Для компиляции используйте команду npm run build. Сгенерированные lua файлы появятся в папке dist.

# Особенности работы транспилера

В этой секции я подробно раскажу про недостатки этого подхода, возможные проблемы и способы их решения.

1. Параметр self

function test() {}
test();

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
function test(self)
end
test(nil)

const obj = {
    a: 5,
    b: 10,
    sum() {
        print(this.a + this.b);
    },
};

obj.sum();

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
obj = {
    a = 5,
    b = 10,
    sum = function(self)
        print(self.a + self.b)
    end
}
obj:sum()

const sum = obj.sum;
sum();

sum = obj.sum
sum(nil)

// tsconfig.json
{
    "compilerOptions": { ... },
    "tstl": {
      	...,
        "noImplicitSelf": false,
        ...
    }
}

function test(this: void): void {}
test();

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
function test()
end
test()

declare interface Person {
    say(text: string): void;
}

declare const person: Person;

person.say("hi");

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
person:say("hi")

/** @noSelf */
declare interface MyLibrary {
    method1(text: string): void;
    method2(num: number): void;
}

declare const lib: MyLibrary;

lib.method1("text");
lib.method2(123);

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
lib.method1("text")
lib.method2(123)

2. Множественные значения

function getValues(): [string, number, boolean] {
    return ["text", 123, true];
}

const [str, num, bool] = getValues();

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
function getValues(self)
    return {"text", 123, true}
end
str, num, bool = unpack(
    getValues(nil)
)

/** @tupleReturn */
function getValues(): [string, number, boolean] {
    return ["text", 123, true];
}

const [str, num, bool] = getValues();

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
function getValues(self)
    return "text", 123, true
end
str, num, bool = getValues(nil)

3. Индексы

const arr = [1, 2, 3];
print(arr[1]);

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
arr = {1, 2, 3}
print(arr[2])

const arr = [1, 2, 3];
print(arr.length);

--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
arr = {1, 2, 3}
print(#arr)

# Ссылки

• Официальный сайт и документация TypeScript (англ)
• Серия русских статей по TypeScript
• Документация TypeScriptToLua (англ)
• Тайпинги

Сначала следует разобраться со значениями. Класс - это набор методов (в нашем случае функций), процедур и переменных которые дальше будут наследоваться объектом или другим классом. Объектами называют сущности, обладающие набором свойств и операций над ними. Объект - это производное класса.

В Lua классов как таковых нет, но если пофантазировать, то можно представить функцию как класс, а объект как таблицу.

Создание простого псевдо-класса

function class() --Объявление класса
	--Тело класса
end --Конец класса

function class() --Объявление класса
	local Me = { } --Создание объекта
	return Me --Возвращение объекта (производного класса)
end --Конец класса

function class() --Объявление класса
	local Me = {  --Таблица для методов и переменных
		["Var"] = "HelloWorld"; --Публичная переменная
	}
	local Secret = "Cake = Lie"  --Скрытая переменная
	function Me.PrintVar()
		print(Me.Var)
	end
	function Me.PrintSecret()
		print(Secret)
	end
	return Me --Возвращение объекта (производного класса)
end --Конец класса

local class = require("имя_библиотеки").class -- загрузили класс из другого файла (если его нет в этом)
local Object = class() -- Создание объекта на основе класса
Object.PrintVar() --Вызов первого метода
--> HelloWorld

Object.PrintSecret() --Вызов второго метода
--> Cake = Lie

Object.Var = "BuyWorld" --Изменение значения свойства Var
Object.PrintVar() --Вызов первого метода
--> BuyWorld

Наследование

function parent() --Класс предок для будущего класса наследника
	local Me = { }
        local private = {
            ["Secret"] = 42
        }
	Me.Var = "HelloWorld"
	function Me.PrintVar()
		print(Me.Var)
	end
	return Me
end 

function class()
	local Me = parent() --Перенимаем таблицу объекта из класса parent(), то есть наследуем.
	return Me
end 

function parent()--Класс предок
	local Me = {
		["Var"] = "HelloWorld" --Публичное свойство
	}
	local private = {
		["Secret"] = 42 --Скрытое свойство
	}
	function Me.PrintVar() --Метод
		print(Me.Var)
	end
	return Me, private --Возвращение объекта, а затем таблицы со скрытыми переменными
end
function class() --Класс наследник
	local Me, private = parent() --Наследование
	function Me.getVar() --Функция, возвращающая свойство Var из класса parent
		return Me.Var
	end
	function Me.getSecret()
		return private.Secret --Функция, возвращающая скрытое свойство Secret класса parent
	end
	return Me, private --Этот класс можно наследовать тоже, таким образом, получится двойное наследование
end 

local class = require("filename").class --Нужно, если вы разместили класс в другом файле
--[[
Если вы разместили классы в разных файлах, то следует загружать каждый отдельно, но так как они у меня в одном файле, я вызову только наследника, и это всё равно будет работать.
]]

local object = class() --Создаём объект
object.PrintVar() --Тестим метод из класса предка
--> HelloWorld

print(object.getVar()) --Тестим метод класса class, работающий с Var
--> HelloWorld

print(Me.getSecret()) --Получаем значение скрытого свойства
--> 42

Экономия оперативной памяти

function class()
    return {
        ["foo"] = function()
            --Здесь очень много кода, вычислений, инструкций и т.д.
        end;
        ["var"] = "какая-то переменная, для примера"
    }
    --Оформил тело объекта так, для разнообразия
end 

do --Начало класса
    local function class_foo(self) --Наша "тяжёлая" функция
        --Здесь очень много кода, вычислений, инструкций и т.д.
    end
    function class() --Функция для вызова класса

Только читаемые свойства

function class()
    local private = { } --Таблица со скрытыми свойствами
    private.__index = { --Таблица внутри таблицы скрытых свойств с читаемыми переменными. !!!Важно! Таблица должна сохраняться под ключом __index!!!
        ReadOnly = true; --Читаемое свойство
        Set = function( var ) --Читаемый метод, который изменяет значение читаемого свойства
            private.__index.ReadOnly = var
        end;
    }
    private.secret = 42823 --Скрытое свойство
    private.__newindex = function() end --Метаметод, непозволяющий менять значение таблицы объекта, если приравняете не к функции, а к таблице будет выводить в неё все попытки замены свойств.
    local Me = { } --Сам объект, да он пуст
    setmetatable( Me, private ) --Магия метатаблиц: устанавливает метатаблицу private для объекта
    return Me, private --Зачем я возвращаю таблицу со скрытыми свойствами, смотрите в наследовании
end 

local class = require 'class'.class --Загрузка класса, если он в другом файле.

local object = class() --Получаем объект на основе нашего класса
object.Set( "test" ) --Устанавливаем значение для читаемого свойства читаемой функцией. Напрямую мы это сделать не сможем.
print(object.ReadOnly) --Выводим значение ReadOnly
--> test

object.ReadOnly = "He he!"
--Изменяем значение, надеясь, что это сработает

print(object.ReadOnly) --Но он выводит старое значение
--> test

Вывод. Этот способ реализации ООП в Lua будет работать и в OC и в СС. "Классы" очень похожи на классы из других языков программирования. В моём варианте нет двоеточия, которое приносит странную возможность обработки одного объекта методом другого. Использовать ООП в игре можно для удобной разметки интерфейса в вашей программе (например для создания кнопок), и для экономии системных ресурсов в вашем компьютере внутри компьютера.

Стандартные функции date +%s  в консоли и в интерпретаторе os.date() выдают пока черти что, 1970 год и время с потолка.

Всякие счетчики работы Луа машины и ПК нам тоже не подходят, типа os.clock() и прочих.

Но есть один способ. В ОС можно получить дату модификации файла методом lastModified('filename') из библиотеки filesystem в формате UNIX

Ним и воспользуемся. Модифицируем вспомагательный файл и получим время модификации тут же.

Вот функция получения времени:

-- ======машинное время (время хоста)=======

-- раскомментируйте библиотеку, если она не подключена в вашем коде
--local fs = require("filesystem")  

--(установить для своего часового пояса, -12 : +13, например: -2 или 6)
local TIME_ZONE = 2  

--(не изменять!)
local t_correction = TIME_ZONE * 3600 

local function getTimeHost()
    local file = io.open('/tmp/unix.tmp', 'w')
    file:write('')
    file:close()
    local lastmod = tonumber(string.sub(fs.lastModified('UNIX.tmp'), 1, -4)) + t_correction
    
    --print(lastmod)


    -- Вариант 1
    --local data = os.date('%x', lastmod)
    --local time = os.date('%X', lastmod)
    --return data, time

    -- Вариант 2, eсли нужно все по отдельности
    --local year = os.date('%Y', lastmod)
    --local month = os.date('%m', lastmod)
    --local day = os.date('%d', lastmod)
    --local weekday = os.date('%A', lastmod)
    --local hour = os.date('%H', lastmod)
    --local minute  = os.date('%M', lastmod)
    --local sec  = os.date('%S', lastmod)    
    --return year, month, day, weekday, hour, minute, sec

    -- Вариант 3, но есть нюанс, если число минут(часов) 5, то и будет выдано 5, а не 05!
    --local dt = os.date('*t', lastmod)
    --return dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec
    
    -- Вариант 4, все в куче, как мы привыкли, в правильном формате
    local dt = os.date('%Y.%m.%d %H:%M:%S', lastmod)
    return dt
end

print(getTimeHost())

Вот выдержка из Советской Энциклопедии о UNIX времени. 

Часовой пояс установите, как Вам угодно (например, сейчас 2 на ИТ - это время Киев, 3 - МСК). Формат, который возвращает функция, тоже выберите, какой Вам удобно. Лишние закомментированные строки (--)  удалите.

Теперь легко можно в лог записать любое событие и приписать ему время. Так же можно легко узнать дату и день недели через 234 часов, 36 мин, 40 сек, например, предварительно переведя временной интервал в секунды и потом вернуть астрономическое время. Например вы хотите узнать, через сколько на ИТ вы скрафтите 100К ведер жидкой материи. Это например, 2256 год, 1 апреля, 12:50:12, если не останавливать "генмат" не на секунду

Вот ретурн функции:

Вариант 1: string, string     04/22/15  09:05:56

Вариант 2: number, number, number, string, number, number, number     2015 04 22   Wednesday 09   05  56

Вариант 3: number, number, number, number, number, number     2015 04  22    9   5  56

Вариант 4: string     2015.04.22 09:05:56

и т.п.

По сути вся функция, это 7 строчек. Не нужно никаких гетзапросов выполнять, библ всяких и интернет карт.

Подробнее о форматах os.date() здесь. 

Написал простенькую функцию для листинга методов на экран или на страничку веб сайта, если у Вас имеется интернет карта в ПК.

http://pastebin.com/5nQnM3ED

pastebin get 5nQnM3ED viewmethods.lua

local component = require("component")
local term = require('term')
local text = require("text")
local components = {}
local methods = {}
local offset = 0
term.clear()
for address, name in component.list() do
    if name:len() > offset then
      offset = name:len()
    end
    components[address] = name
end

offset = offset + 2
print(' -------- Найденные компоненты --------')
for address, name in pairs(components) do
  io.write(text.padRight(name, offset) .. address .. '\n')
end
print(' --------------------------------------')
io.write('Введите имя компонента, методы которого нужно узнать: \n>> ')
local name = io.read()
if component.isAvailable(name) then
	t = component.getPrimary(name)
	local filename = name..'_doc.tmp'
	local file = io.open(filename, 'w')
	for k,v in pairs(t) do
		table.insert(methods,'>> Метод: '..k..'\nДокументация: '..tostring(v))
    	file:write('>> Метод: '..k..'\nДокументация: '..tostring(v)..'\n')
	end
	file:close()
	if component.isAvailable('internet') then
		print('Перейдите по ссылке на сайт для ознакомления!')
		require('shell').execute('pastebin put '..filename)
		else
			term.clear()
			print('Нажимайте ENTER для продолжения')
			for k,v in pairs(methods) do
				print('['..k..'] '..v)
				io.read()
			end
	end
else
	print('Ошибка. Компонента '..name..' не существует!')
end

Допустим, захотелось нам иметь резидентную программу, которая будет работать на фоне OpenOS и, периодически, или по какому либо событию, что-то полезное делать.

Воспользуемся нашим маленьким bibi, а в качестве boot.lua напишем такой код:

local cl=component.list
local gp=component.proxy(cl("gpu")())

--сохраняем исходные функции из _G.computer, для внутреннего пользования
local cp={} for k,v in pairs(computer) do cp[k]=v end

--подменяем функцию computer.pullSignal
computer.pullSignal = function (...)
  local e={cp.pullSignal(...)}
 --для примера, по тильде (~) будем ребутать компьютер
  if e[1]=='key_down' and e[4]==41 then cp.shutdown(true) end
  --а по lAlt будем выводить список компонентов используя определенную в OpenOS функцию print и сохраненную cl
  if e[1]=='key_down' and e[4]==56 then
    for k,v in cl() do print(k,v) end
  end
  --OpenOS периодически сама дергает эвенты (чтобы курсор мигал и прочее) подробнее смотрите в lib/event.lua
  --поэтому мы можем выводить свои часики, куда-ж без них то ) и прочие полезности, например инфу о памяти
  local s=tostring(math.floor(cp.freeMemory()/1024))..'/'..tostring(cp.totalMemory()/1024)..' kb free '..os.date('!%R')
  local w,h = gp.maxResolution()
  gp.set(w-#s+1,1,s)
  --в конце мы должны вернуть событие ничего не подозревающей OpenOS
  return table.unpack(e)
end

--функцию мы подменили, теперь загружаем, компилируем и выполняем init.lua
local fs=component.proxy(computer.getBootAddress())
local h=fs.open('init.lua')
local s,r='',''
while r do
  r=fs.read(h,math.huge)
  s=s..(r or "")
end
fs.close(h)
load(s)()

Теперь мы можем нажать lAlt и лицезреть список компонентов, или нажать тильду, и компьютер перезапустится.

--==--

Конечно, вы можете сказать, что вывод списка компонентов портит экран, что перед выводом хорошо бы сохранять состояние экрана каким-нибудь gpu.get, вывод делать в свой интерфейс, а после, восстанавливать экран. И часики у меня никудышние. При скролле вниз (например в редакторе edit.lua) скроллируются вместе с текстом, вместо того, чтобы оставаться там где им положено. Но моя задача, показать метод на простейших примерах, а не переопределяя gpu строить интерфейсы.

На основе этого метода можно построить API для TSR программ, а комбинируя его с перехватом component.proxy, component.invoke и последующей подменой gpu на виртуальный терминал, и вовсе, написать свою операционную систему. Для которой, кстати говоря, было бы неплохо уметь запускать OpenOS в окошке, но самое главное, в изолированной среде, чтобы труд программистов писавших ПО под OpenOS не пропадал зря.

Я бы даже сказал, что изоляция OpenOS, на данном этапе, более важная задача, чем построение интерфейсов. Поэтому мы попробуем разобрать эту проблему в следующей статье.

Посмотрим что выйдет.

--==--

Небольшое дополнение:

Если вам не охота играть с bibi, но нужно запустить резидентную программу прямо из-под OpenOS, то это сделать еще проще.

local component = require("component")
local cp = require("computer")
local gpu = component.gpu
local pullSignal = cp.pullSignal

cp.pullSignal = function (...)
  local e={pullSignal(...)}
  if e[1]=='key_down' and e[4]==41 then cp.shutdown(true) end
  if e[1]=='key_down' and e[4]==56 then for k,v in component.list() do print(k,v) end end
  local s=' '..math.floor(cp.freeMemory()/1024)..'/'..(cp.totalMemory()/1024)..' kb free  '..os.date('!%R')
  local w,h = gpu.maxResolution() gpu.set(w-#s+1,1,s)  
  return table.unpack(e)
end

Программа выполнится, завершится, а резидентный участок останется в памяти.

--==--

Если выбросить все что относится к демонстрации работы, у нас останется маленькая обертка

local cp = require("computer")
local pullSignal = cp.pullSignal
cp.pullSignal = function (...)
  local e={pullSignal(...)}

  --код TSR программы

  return table.unpack(e)
end

Мы привыкли писать программы для OpenComputers на Луа. И при этом не задумываемся о том, что язык Луа в OpenComputers - это по сути "язык низкого уровня".
На нем мы пишем все - начиная от прошивок BIOS и операционных систем, и заканчивая чатиками для OpenGlasses.
 
Однако, когда объем кода не имеет решающей роли, и есть время для медитации, программист может дать душе отдохнуть, используя красивые конструкции высокоуровневых языков.
И таким языком сегодня станет MoonScript.
 
 
# Что это такое?
MoonScript - это язык с интересным и лаконичным синтаксисом. Он позволяет использовать привычные конструкции ООП (объектно-ориентированное программирование) и ФП (функциональное программирование) в сеттинге Луа.
Сам автор называет его "CoffeeScript for Lua".
 
Код на MoonScript хранится в файликах с расширением *.moon и транслируется в обычный код Lua. Который может затем быть выполнен на компьютерах или роботах OpenComputers.
 
Плюсы:
* краткий и красивый код (субъективно)
* изучение нового, интересного (объективно)
 
Минусы:
* Транслированный код хуже читаем, и немного объемнее, чем аналогичный код, написанный изначально на Луа
 
 
# Установка
Приведу пример установки для Debian + Lua5.3. Если у вас другая OS - смотрите соответствующие инструкции по ссылкам.
 
1) Lua (https://www.lua.org/start.html)

$ sudo apt-get install lua5.3

2) Пакетный менеджер LuaRocks (https://luarocks.org/#quick-start)
Для его установки возможно потребуется пакет liblua5.3-dev.
Установим его командой:

$ sudo apt-get install liblua5.3-dev

Далее следуем инструкциям с официального сайта:

$ wget http://luarocks.org/releases/luarocks-2.3.0.tar.gz
$ tar zxpf luarocks-2.3.0.tar.gz
$ cd luarocks-2.3.0
$ ./configure; sudo make bootstrap

3) Ставим пакеты MoonScript (http://moonscript.org/#installation)

$ sudo luarocks install moonscript

Теперь в системе появятся программы moon и moonc. Ура!
 
К слову, при их запуске может вылетать ошибка типа

/usr/local/share/lua/5.3/alt_getopt.lua:24: attempt to call a nil value (global 'module')

Это происходит потому, что moonscript давненько уже не обновлялся, и использует устаревшее ключевое слово module.

Фиксится при помощи правки файликов alt_getopt.lua и moon.
 
В файле alt_getopt.lua необходимо закомментировать 24 строку (module ("alt_getopt")) и дописать в самый конец строку

return {get_opts = get_opts, get_ordered_opts = get_ordered_opts}

В файле moon исправляем вторую строку на

local alt_getopt = require("alt_getopt")

Все это в нашем случае можно сделать командами:

$ sudo gedit /usr/local/share/lua/5.3/alt_getopt.lua
$ sudo gedit /usr/local/lib/luarocks/rocks/moonscript/0.4.0-1/bin/moon

Все! MoonScript установлен, пропатчен и готов к работе.
 
 
# Подсветка синтаксиса
Очень рекомендую писать код в редакторе заточенном под код. Чертовски удобно, поверьте.
Для MoonScript существуют пакеты подсветки синтаксиса для разных редакторов.
 
1) Sublime Text / Text Mate - https://github.com/leafo/moonscript-tmbundle
2) vim - https://github.com/leafo/moonscript-vim
3) Atom - https://atom.io/packages/language-moonscript
4) Textadept - https://github.com/leafo/moonscript-textadept
 
 
# А теперь - магия!
Для примера, я переписал код библиотечки Braille Bicycle с использованием MoonScript.
Теперь она использует ООП подход (привет, @Krutoy  ).
http://pastebin.com/NQc7JCH3
 
Этот файлик я потом "откомпилировал" в Lua простой командой:

$ moonc braille.moon

И получил на выходе рабочую библиотеку braille.lua.
Далее, заливаем ее в OC и пишем простой тестовый код:

local gpu = require('component').gpu
local braille = require('braille')


local matrix = braille.Matrix(8, 8)
matrix:line(1, 1, 8, 1)
matrix:set(1, 2); matrix:line(4, 2, 5, 2); matrix:set(8, 2)
matrix:set(1, 3); matrix:line(4, 3, 5, 3); matrix:set(8, 3)
matrix:line(1, 4, 3, 4); matrix:line(6, 4, 8, 4)
matrix:line(1, 5, 2, 5); matrix:line(7, 5, 8, 5)
matrix:line(1, 6, 2, 6); matrix:line(7, 6, 8, 6)
matrix:line(1, 7, 2, 7); matrix:line(4, 7, 5, 7); matrix:line(7, 7, 8, 7)
matrix:line(1, 8, 8, 8)


gpu.setForeground(0xC61331)
matrix:render(gpu, 14, 12)
matrix:render(gpu, 46, 12)
gpu.setForeground(0xFFFFFF)
matrix:render(gpu, 30, 12)
matrix:render(gpu, 62, 12)

И вуаля! Работает. 
 

 
# Игровая трансляция
Все это хорошо, но иногда может быть полезна возможность использовать *.moon исходники прямо из OC, без предварительной компиляции.
Уже поздно, поэтому расскажу об этом как-нибудь в другой раз. 

Скажу лишь, что помимо всего прочего, у MoonScript есть такая любопытная тулза, как онлайн "компилятор". Его можно найти вот здесь:

http://moonscript.org/compiler/

# UPD

Товарищи @Krutoy и @evgkul выпустили транслятор MoonScript на чистом Луа, что позволяет запускать и "компилировать" программы MoonScript прямо из OpenOS.

Заценить и потестить можно по этой ссылке:

https://github.com/evgkul/moonscript-opencomputers

Пишите багрепорты (сюда или на GitHub), и отправляйте свои пуллреквесты, чтобы улучшить программу.

# UPD 3

Добавил MoonScript в репозиторий. Теперь можно установить его и потестить всего одной командой:

hpm install moon