Oleshe

local gui = require('gui')
local event = require('event')
local fs= require('filesystem')
local elements = {} -- Будещее...
local camera = {x=1,y=1} --Вроде не нужно, но этоже еще в разработке)
local player = {x=50,y=25,facing='Right'} -- информация об игроке
local image = require('image')
local images = {} -- Вперёд в будущее (по тексту)
local key = require('keyboard')

images['Brick'] = image.load('/Brick.pic') -- будущее настало
images['Man Left'] = image.load('/Man.pic')
images['Man Right'] = image.flipHorizontally(image.load('Man.pic'))
images['Man Up'] = image.load('/Mann.pic')
images['Man Down'] = image.flipVertically(image.load('Mann.pic')) -- Заранее подгружаем пикчи что-бы не грузить диск по любомму требованию

wk  = gui.workspace(1,1,160,50)
local bg = wk:addChild(gui.panel(1,1,160,50,0xFFFFFF)) -- Задний фон
local text = wk:addChild(gui.text(20,20,0x989898,'0 0'))
local data = fs.readTable('/Test.map') -- {[1]={[1]='Brick'},X=1,Y=1} --Карта
local map = wk:addChild(gui.container(1,1,160,50)) -- Наш пациент, контейнер
local playerpic = wk:addChild(gui.image(50,25,images['Man Right']))
local a=  0 
for x=1,160 do -- потом карта будет сама определять свой размер, исходя из файлы карты
  for y=1,50 do
    a = a + 1
    pcall(function()
    -- Второе будущее
    elements[a] = map:addChild(gui.image(x,y,images[data[x][y]])) -- Спавн элементов карты, координаты и что за элемент там хранится, в будущем будет колайды (можно ли уперется в объект (пол и тумбочка)), а также делаем так,что-бы мы могли в будущем управлять компонентами карты запихивая в "элементы"(карты)
    end)
  end
end
while true do
  e1,e2,e3,e4,e5,e6=event.pull(0.01)
  text.text = tostring(e3)..' '..tostring(e4)
  playerpic:remove() -- Дабы не рисовать супер линий игроком
  if key.isKeyDown(30) then -- A
    if player.x > 20 then
    player.facing = 'Left'
    player.x = player.x - 2
    else
    map.localX = map.localX-2 end
  end
  if key.isKeyDown(32) then -- D
    if player.x < 140 then
    player.facing = 'Right'
    player.x = player.x + 2
    else
    map.localX = map.localX+2 end
  end
  if key.isKeyDown(17) then -- W
    if player.y > 10 then
    player.y = player.y - 1
    player.facing = 'Up'
    else
    map.localY = map.localY-1
    end
  end
  if key.isKeyDown(31) then -- S
    if player.y < 40 then
    player.y = player.y + 1
    player.facing = 'Down'
    else
      map.localY = map.localY+1
    end
  end
  local playerpic = wk:addChild(gui.image(player.x,player.y,images['Man '..player.facing])) -- показываем игрока, снова
  wk:draw()
end
wk:draw()
wk:start()

-------------------------------------------------------- Libraries --------------------------------------------------------

local color = require("Color")
local screen = require("Screen")
local event = require("Event")
local GUI = require("GUI")
local vector = require("Vector")
local materials = require("OpenComputersGL/Materials")
local renderer = require("OpenComputersGL/Renderer")
local OCGL = require("OpenComputersGL/Main")
local meowEngine = require("MeowEngine/Main")

---------------------------------------------- Anus preparing ----------------------------------------------

-- /MineOS/Desktop/3DTest.app/3DTest.lua

screen.flush()
meowEngine.intro(vector.newVector3(0, 0, 0), 20)

local workspace = GUI.workspace()
local scene = meowEngine.newScene(0x1D1D1D)

scene.renderMode = OCGL.renderModes.flatShading
scene.auxiliaryMode = OCGL.auxiliaryModes.disabled

scene.camera:translate(-2.5, 8.11, -19.57)
scene.camera:rotate(math.rad(30), 0, 0)
scene:addLight(meowEngine.newLight(vector.newVector3(0, 20, 0), 1.0, 200))
scene:addLight(meowEngine.newLight(vector.newVector3(0, 0, 0), 1.0, 200))
scene:addLight(meowEngine.newLight(vector.newVector3(20, 20, 0), 1.0, 200))
scene:addLight(meowEngine.newLight(vector.newVector3(0, 20, 20), 1.0, 200))
scene:addLight(meowEngine.newLight(vector.newVector3(20, 20, 20), 1.0, 200))

---------------------------------------------- Constants ----------------------------------------------

local blockSize = 5
local rotationAngle = math.rad(5)
local translationOffset = 1

---------------------------------------------- Voxel-world system ----------------------------------------------

local world = {{{}}}

local worldMesh = scene:addObject(
	meowEngine.newMesh(
		vector.newVector3(0, 0, 0), { }, { },
		materials.newSolidMaterial(0xFF00FF)
	)
)

local function checkBlock(x, y, z)
	if world[z] and world[z][y] and world[z][y][x] then
		return true
	end
	return false
end

local function setBlock(x, y, z, value,size) -- изменено
	world[z] = world[z] or {}
	world[z][y] = world[z][y] or {}
	world[z][y][x] = {value,size}
end

local blockSides = {
	front = 1,
	left = 2,
	back = 3,
	right = 4,
	up = 5,
	down = 6
}

local function renderWorld()
	worldMesh.vertices = {}
	worldMesh.triangles = {}

	for z in pairs(world) do
		for y in pairs(world[z]) do
			for x in pairs(world[z][y]) do
				local firstVertexIndex = #worldMesh.vertices + 1
				local xBlock, yBlock, zBlock = (x - 1) * world[z][y][x][2][1], (y-1) * world[z][y][x][2][2], (z - 1) * world[z][y][x][2][3] -- именено
				local material = materials.newSolidMaterial(world[z][y][x][1])-- именено

				table.insert(worldMesh.vertices, vector.newVector3(xBlock, yBlock, zBlock))-- именено
				table.insert(worldMesh.vertices, vector.newVector3(xBlock, yBlock + world[z][y][x][2][2], zBlock))-- именено
				table.insert(worldMesh.vertices, vector.newVector3(xBlock + world[z][y][x][2][1], yBlock + world[z][y][x][2][2], zBlock))-- именено
				table.insert(worldMesh.vertices, vector.newVector3(xBlock + world[z][y][x][2][1], yBlock, zBlock))-- именено
				table.insert(worldMesh.vertices, vector.newVector3(xBlock, yBlock, zBlock + world[z][y][x][2][3]))-- именено
				table.insert(worldMesh.vertices, vector.newVector3(xBlock, yBlock + world[z][y][x][2][2], zBlock + world[z][y][x][2][3]))-- именено
				table.insert(worldMesh.vertices, vector.newVector3(xBlock + world[z][y][x][2][1], yBlock + world[z][y][x][2][2], zBlock + world[z][y][x][2][3]))-- именено
				table.insert(worldMesh.vertices, vector.newVector3(xBlock + world[z][y][x][2][1], yBlock, zBlock + world[z][y][x][2][3]))-- именено
				
				-- Front (1, 2)
				if not checkBlock(x, y, z - 1) then
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex, firstVertexIndex + 1, firstVertexIndex + 2, material))
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 3, firstVertexIndex, firstVertexIndex + 2, material))
				end

				-- Left (3, 4)
				if not checkBlock(x - 1, y, z) then
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 5, firstVertexIndex + 1, firstVertexIndex + 4, material))
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 1, firstVertexIndex, firstVertexIndex + 4, material))
				end

				-- Back (5, 6)
				if not checkBlock(x, y, z + 1) then
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 6, firstVertexIndex + 5, firstVertexIndex + 7, material))
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 5, firstVertexIndex + 4, firstVertexIndex + 7, material))
				end

				-- Right (7, 8)
				if not checkBlock(x + 1, y, z) then
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 3, firstVertexIndex + 2, firstVertexIndex + 6, material))
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 7, firstVertexIndex + 3, firstVertexIndex + 6, material))
				end

				-- Up (9, 10)
				if not checkBlock(x, y + 1, z) then
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 1, firstVertexIndex + 5, firstVertexIndex + 6, material))
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 2, firstVertexIndex + 1, firstVertexIndex + 6, material))
				end

				-- Down (11, 12)
				if not checkBlock(x, y - 1, z) then
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex + 4, firstVertexIndex, firstVertexIndex + 7, material))
					table.insert(worldMesh.triangles, OCGL.newIndexedTriangle(firstVertexIndex, firstVertexIndex + 3, firstVertexIndex + 7, material))
				end
			end
		end
	end
end

-- Mode 1
-- именено до...
local cube = {top={},bottom={},left={},right={},forward={},back={}}
i= 0
for z = -1, 1 do
	for x = -1, 1 do
		i= i + 1
		setBlock(x, 0, z, 0xFFFF00,{2,1,2})
		cube.bottom[i] = {'yellow',x,0,z}
	end
end
i= 0
for z = -1, 1 do
	for x = -1, 1 do
		i= i + 1
		setBlock(x, 7, z, 0xFFFFFF,{2,1,2})
		cube.top[i] = {'white',x,7,z}
	end
end
i= 0
y = 0
while y < 6 do -- Наша стенка
for x = -1, 1 do
	i= i + 1 -- элемент, кубик рубика, на 1 стороне 9 элементов которыйе мы и генерируем
	setBlock(x, y, -4, 0xFFA500,{2,2,1}) -- ставим понель
	cube.back[i] = {'orange',x,y+1,-1} -- для того что-бы сторона была цветная и мы могли получить координаты нужной нам панели
end 
y = y + 2
end
-- сюда --
-- -- Mode 2
-- for z = 1, 7 do
-- 	for x = -3, 3 do
-- 		setBlock(x, 0, z, 0xFFFFFF)
-- 	end
-- end

---------------------------------------------- Cat ----------------------------------------------

-- scene:addObject(meowEngine.newPolyCatMesh(vector.newVector3(0, 5, 0), 5))
-- scene:addObject(meowEngine.newFloatingText(vector.newVector3(0, -2, 0), 0xEEEEEE, "Тест плавающего текста"))

---------------------------------------------- Texture ----------------------------------------------

-- scene.camera:translate(0, 20, 0)
-- scene.camera:rotate(math.rad(90), 0, 0)
-- local texturedPlane = scene:addObject(meowEngine.newTexturedPlane(vector.newVector3(0, 0, 0), 20, 20, materials.newDebugTexture(16, 16, 40)))

---------------------------------------------- Wave ----------------------------------------------

-- local xCells, yCells = 4, 1
-- local plane = meowEngine.newPlane(vector.newVector3(0, 0, 0), 40, 15, xCells, yCells, materials.newSolidMaterial(0xFFFFFF))
-- plane.nextWave = function(mesh)
-- 	for xCell = 1, xCells do
-- 		for yCell = 1, yCells do
			
-- 		end
-- 	end
-- end

---------------------------------------------- Fractal field ----------------------------------------------

-- local function createField(vector3Position, xCellCount, yCellCount, cellSize)
-- 	local totalWidth, totalHeight = xCellCount * cellSize, yCellCount * cellSize
-- 	local halfWidth, halfHeight = totalWidth / 2, totalHeight / 2
-- 	xCellCount, yCellCount = xCellCount + 1, yCellCount + 1
-- 	local vertices, triangles = {}, {}

-- 	local vertexIndex = 1
-- 	for yCell = 1, yCellCount do
-- 		for xCell = 1, xCellCount do
-- 			table.insert(vertices, vector.newVector3(xCell * cellSize - cellSize - halfWidth, yCell * cellSize - cellSize - halfHeight, 0))

-- 			if xCell < xCellCount and yCell < yCellCount then
-- 				table.insert(triangles,
-- 					OCGL.newIndexedTriangle(
-- 						vertexIndex,
-- 						vertexIndex + 1,
-- 						vertexIndex + xCellCount
-- 					)
-- 				)
-- 				table.insert(triangles,
-- 					OCGL.newIndexedTriangle(
-- 						vertexIndex + 1,
-- 						vertexIndex + xCellCount + 1,
-- 						vertexIndex + xCellCount
-- 					)
-- 				)
-- 			end

-- 			vertexIndex = vertexIndex + 1
-- 		end
-- 	end

-- 	local mesh = meowEngine.newMesh(vector3Position, vertices, triangles,materials.newSolidMaterial(0xFF8888))
	
-- 	local function getRandomSignedInt(from, to)
-- 		return (math.random(0, 1) == 1 and 1 or -1) * (math.random(from, to))
-- 	end

-- 	local function getRandomDirection()
-- 		return getRandomSignedInt(5, 100) / 100
-- 	end

-- 	mesh.randomizeTrianglesColor = function(mesh, hueChangeSpeed, brightnessChangeSpeed, minimumBrightness)
-- 		mesh.hue = mesh.hue and mesh.hue + hueChangeSpeed or math.random(0, 360)
-- 		if mesh.hue > 359 then mesh.hue = 0 end

-- 		for triangleIndex = 1, #mesh.triangles do
-- 			mesh.triangles[triangleIndex].brightness = mesh.triangles[triangleIndex].brightness and mesh.triangles[triangleIndex].brightness + getRandomSignedInt(1, brightnessChangeSpeed) or math.random(minimumBrightness, 100)
-- 			if mesh.triangles[triangleIndex].brightness > 100 then
-- 				mesh.triangles[triangleIndex].brightness = 100
-- 			elseif mesh.triangles[triangleIndex].brightness < minimumBrightness then
-- 				mesh.triangles[triangleIndex].brightness = minimumBrightness
-- 			end
-- 			mesh.triangles[triangleIndex][4] = materials.newSolidMaterial(color.HSBToInteger(mesh.hue, 1, mesh.triangles[triangleIndex].brightness))
-- 		end
-- 	end

-- 	mesh.randomizeVerticesPosition = function(mesh, speed)
-- 		local vertexIndex = 1
-- 		for yCell = 1, yCellCount do
-- 			for xCell = 1, xCellCount do
-- 				if xCell > 1 and xCell < xCellCount and yCell > 1 and yCell < yCellCount then
-- 					mesh.vertices[vertexIndex].offset = mesh.vertices[vertexIndex].offset or {0, 0}
-- 					mesh.vertices[vertexIndex].direction = mesh.vertices[vertexIndex].direction or {getRandomDirection(), getRandomDirection()}

-- 					local newOffset = {
-- 						mesh.vertices[vertexIndex].direction[1] * (speed * cellSize),
-- 						mesh.vertices[vertexIndex].direction[1] * (speed * cellSize)
-- 					}
					
-- 					for i = 1, 2 do
-- 						if math.abs(mesh.vertices[vertexIndex].offset[i] + newOffset[i]) < cellSize / 2 then
-- 							mesh.vertices[vertexIndex].offset[i] = mesh.vertices[vertexIndex].offset[i] + newOffset[i]
-- 							mesh.vertices[vertexIndex][i] = mesh.vertices[vertexIndex][i] + newOffset[i]
-- 						else
-- 							mesh.vertices[vertexIndex].direction[i] = getRandomDirection()
-- 						end
-- 					end
-- 				end
-- 				vertexIndex = vertexIndex + 1
-- 			end
-- 		end
-- 	end

-- 	return mesh
-- end

-- local plane = createField(vector.newVector3(0, 0, 0), 8, 4, 4)
-- scene:addObject(plane)
-- plane:randomizeTrianglesColor(10, 10, 50)

-------------------------------------------------------- Controls --------------------------------------------------------
 -- удалён весь UI Отвечаеший за изменение света и т.д., полностью удалён toolbox 
local function move(x, y, z)
	local moveVector = vector.newVector3(x, y, z)
	OCGL.rotateVectorRelativeToXAxis(moveVector, scene.camera.rotation[1])
	OCGL.rotateVectorRelativeToYAxis(moveVector, scene.camera.rotation[2])
	scene.camera:translate(moveVector[1], moveVector[2], moveVector[3])
end

local controls = {
	-- Arrows
	[200] = function() scene.camera:rotate(-rotationAngle, 0, 0) end,
	[208] = function() scene.camera:rotate(rotationAngle, 0, 0) end,
	[203] = function() scene.camera:rotate(0, -rotationAngle, 0) end,
	[205] = function() scene.camera:rotate(0, rotationAngle, 0) end,
	[16 ] = function() scene.camera:rotate(0, 0, rotationAngle) end,
	[18 ] = function() scene.camera:rotate(0, 0, -rotationAngle) end,
	-- WASD
	[17 ] = function() move(0, 0, translationOffset) end,
	[31 ] = function() move(0, 0, -translationOffset) end,
	[30 ] = function() move(-translationOffset, 0, 0) end,
	[32 ] = function() move(translationOffset, 0, 0) end,
	-- RSHIFT, SPACE
	[42 ] = function() move(0, -translationOffset, 0) end,
	[57 ] = function() move(0, translationOffset, 0) end
}

-------------------------------------------------------- GUI --------------------------------------------------------

local OCGLView = GUI.object(1, 1, workspace.width, workspace.height)

local function drawInvertedText(x, y, text)
	local index = screen.getIndex(x, y)
	local background, foreground = screen.rawGet(index)
	screen.rawSet(index, background, 0xFFFFFF - foreground, text)
end

local function drawCross(x, y)
	drawInvertedText(x - 2, y, "━")
	drawInvertedText(x - 1, y, "━")
	drawInvertedText(x + 2, y, "━")
	drawInvertedText(x + 1, y, "━")
	drawInvertedText(x, y - 1, "┃")
	drawInvertedText(x, y + 1, "┃")
end

OCGLView.draw = function(object)
	workspace.oldClock = os.clock()
	if world then renderWorld() end
	scene:render()
	drawCross(renderer.viewport.xCenter, math.floor(renderer.viewport.yCenter / 2))
end
workspace:addChild(OCGLView)

workspace.infoTextBox = workspace:addChild(GUI.textBox(2, 4, 45, workspace.height, nil, 0xEEEEEE, {}, 1, 0, 0))
local lines = {
	"Copyright © 2016-2017 - Developed by ECS Inc.",
	"Timofeef Igor (vk.com/id7799889), Trifonov Gleb (vk.com/id88323331), Verevkin Yakov (vk.com/id60991376), Bogushevich Victoria (vk.com/id171497518)",
	"All rights reserved",
}
workspace:addChild(GUI.textBox(1, workspace.height - #lines + 1, workspace.width, #lines, nil, 0x3C3C3C, lines, 1)):setAlignment(GUI.ALIGNMENT_HORIZONTAL_CENTER, GUI.ALIGNMENT_VERTICAL_TOP)

local elementY = 2
local elementWidth = 20 - 2 -- именено

local FPSCounter = GUI.object(2, 2, 8, 3)
FPSCounter.draw = function(FPSCounter)
	renderer.renderFPSCounter(FPSCounter.x, FPSCounter.y, tostring(math.ceil(1 / (os.clock() - workspace.oldClock) / 10)), 0xFFFF00)
end
workspace:addChild(FPSCounter)

workspace.eventHandler = function(workspace, object, e1, e2, e3, e4, e5)
		workspace.infoTextBox.lines = {
			" ",
			"SceneObjects: " .. #scene.objects,
			" ",
			"OCGLVertices: " .. #OCGL.vertices,
			"OCGLTriangles: " .. #OCGL.triangles,
			"OCGLLines: " .. #OCGL.lines,
			"OCGLFloatingTexts: " .. #OCGL.floatingTexts,
			"OCGLLights: " .. #OCGL.lights,
			" ",
			"CameraFOV: " .. string.format("%.2f", math.deg(scene.camera.FOV)),
			"СameraPosition: " .. string.format("%.2f", scene.camera.position[1]) .. " x " .. string.format("%.2f", scene.camera.position[2]) .. " x " .. string.format("%.2f", scene.camera.position[3]),
			"СameraRotation: " .. string.format("%.2f", math.deg(scene.camera.rotation[1])) .. " x " .. string.format("%.2f", math.deg(scene.camera.rotation[2])) .. " x " .. string.format("%.2f", math.deg(scene.camera.rotation[3])),
			"CameraNearClippingSurface: " .. string.format("%.2f", scene.camera.nearClippingSurface),
			"CameraFarClippingSurface: " .. string.format("%.2f", scene.camera.farClippingSurface),
			"CameraProjectionSurface: " .. string.format("%.2f", scene.camera.projectionSurface),
			"CameraPerspectiveProjection: " .. tostring(scene.camera.projectionEnabled),
			" ",
			"Controls:",
			" ",
			"Arrows - camera rotation",
			"WASD/Shift/Space - camera movement",
			"LMB/RMB - destroy/place block",
			"NUM 8/2/4/6/1/3 - selected light movement",
			"F1 - toggle GUI overlay",
		}

		workspace.infoTextBox.height = #workspace.infoTextBox.lines

	if e1 == "key_down" then
		if controls[e4] then
			controls[e4]()
		end
	elseif e1 == "scroll" then
		if e5 == 1 then
			if scene.camera.FOV < math.rad(170) then
				scene.camera:setFOV(scene.camera.FOV + math.rad(5))
			end
		else
			if scene.camera.FOV > math.rad(5) then
				scene.camera:setFOV(scene.camera.FOV - math.rad(5))
			end
		end
	end

	workspace:draw()
end

-------------------------------------------------------- Ebat-kopat --------------------------------------------------------

workspace:start(0)

images = {}
images.down = image.load(path..'/Images/down.pic')
images.up = image.load(path..'/Images/up.pic')
images.left = image.load(path..'/Images/left.pic')
images.right = image.load(path..'/Images/right.pic')
images.downd = image.load(path..'/Images/downd.pic') -- с префиксом d - deactivated, когда стрелка не нажата
images.upd = image.load(path..'/Images/upd.pic')
images.leftd = image.load(path..'/Images/rightd.pic')
images.rightd = image.load(path..'/Images/leftd.pic')
return images

 Оно загружает через loadfile и сразу запускает, path как ни страно хранит корневую папку приложения '/Mounts/bb8...82e/test.app'

todraw = {[1]={['time'] = 30,['arrows'] = {['right'] = true, ['left'] = true},[1] = 1}} -- по умолчаний ставится в другом скрипте, хранит данные о стрелках на определённую милисекунду + "сторону" на которой стрелка и время (пиксель)
-- (картинки 10 на 5)
-- wrk созданный на несовсем правом верхнем углу объект workspace с достаточным размером (проверялось), и потомучто это не "окно", оно сбрасывает дисплей поэтому оно будет видно и не надо ничего удалять. Но идёт ущерб графической производительности (сделан "разгон" на CallBuget в конфиге)
exit = false -- по умолчаний ставится в другом скрипте, но для тестов оно тут
--thread.create(function()
while exit == false do
  event.sleep(0)
  b = 0
  while b < #todraw do
    b = b + 1
   if todraw[b] then
      tmptime = todraw[b]['time'] -- обход ошибки
      print(todraw[b]['arrows'].right)
      if not tmptime then -- вот тут
         tmptime = 50
      end
      tmparrows = todraw[b]['arrows']
      if tmparrows.right == true then
        wrk:addChild(gui.image(34,todraw[b].time,images.right))
      end
      if todraw[b]['arrows'].up then
        wrk:addChild(gui.image(23,todraw[b].time,images.up))
      end
      if todraw[b]['arrows'].down then
        wrk:addChild(gui.image(12,todraw[b].time,images.down))
      end
      if todraw[b]['arrows'].left then
        wrk:addChild(gui.image(1,todraw[b].time,images.left))
      end
      todraw[b]['time'] = todraw[b].time - 1
      if todraw[b]['time'] == -6 then -- если вышла за экран удаляем в общем
        todraw[b] = nil
      end
    end
   end
end --end)