Grid

--!strict
--Tentaizu

--[[
	Acts as a container for all information about the grid, including storage system for Mine objects.
--]]
local player = game.Players.LocalPlayer

local starterPlayerScripts = player.PlayerScripts
local modules = starterPlayerScripts.Scripts.Modules

local replicatedStorage = game.ReplicatedStorage
local gridFolder = game.Workspace.Grid
local camera = game.Workspace.CurrentCamera

local mine = require(script:WaitForChild("Mine"))
local visuals = require(modules:WaitForChild("WorldInteraction"):WaitForChild("Visuals"))
local Janitor = require(replicatedStorage.Janitor)

local upperbounds = gridFolder.Upperbounds.Position
local lowerbounds = gridFolder.Lowerbounds.Position

local grid = {}
grid.__index = grid

local BOMBCOUNT = 40
local PADDING = 3
local OBJECTS = Vector3.new(13, 5, 5)

--local Mines = table.create(OBJECTS.X, table.create(OBJECTS.Y, table.create(OBJECTS.Z, nil)))
local Mines = {}
for x = 1, OBJECTS.X do
	Mines[x] = {}
	for y = 1, OBJECTS.Y do
		Mines[x][y] = {}
		for z = 1, OBJECTS.Z do
			Mines[x][y][z] = nil--[insert data here]
		end
	end
end

--[[Start of local functions]]

--[[
	Determines if a certain point is visible on screen. 
	@param pos
	@return boolean
--]]
local function isVisible(pos : Vector3)	
	local _, isOnScreen = camera:WorldToScreenPoint(pos)
	return isOnScreen

end

--[[
	Determines if a position meets the constraints put forth by the grid
	@param pos
	@return boolean
--]]
local function isValidPos(pos : Vector3)
	if pos.X <= 0 or pos.X > OBJECTS.X then
		return false
	end
	
	if pos.Y <= 0 or pos.Y > OBJECTS.Y then
		return false
	end
	
	if pos.Z <= 0 or pos.Z > OBJECTS.Z then
		return false
	end
	
	if not isVisible(pos) then
		return false
	end

	return true
end


--[[
	Will update all neighbors of the cell at pos to accomodate for pos being a 'bomb'
	@param pos
	@return 
--]]
local function updateNeighbors(pos : Vector3)
	for x = pos.X - 1, pos.X + 1 do
		for y = pos.Y - 1, pos.Y + 1 do
			for z = pos.Z - 1, pos.Z + 1 do
				
				if isValidPos(Vector3.new(x, y, z)) then
					local mine = Mines[x][y][z]

					mine.Neighbors += 1
					
				end
			end

		end
	end
end

--[[
	Randomly place bombs across the grid
	@param
	@return
--]]
local function generateBombs()
	local randomVectors = {}
	local random = Random.new(math.floor(tick() / math.pi * 1000)) --Sets the seed
	
	--Generates the bombs
	local i = BOMBCOUNT
	while i > 0 do
		--The location of the bomb

		local vec = Vector3.new(
			random:NextInteger(1, OBJECTS.X), 
			random:NextInteger(1, OBJECTS.Y),
			random:NextInteger(1, OBJECTS.Z))

		--If location is not already a bomb, make it a bomb
		if not table.find(randomVectors, vec) then

			table.insert(randomVectors, vec)

			--Assigns the status
			Mines[vec.X][vec.Y][vec.Z].Bomb = true

			--Updates neighboring tiles
			updateNeighbors(vec)

			i -= 1
		end
	end
end
--[[
	Determines if a certain mine is visible or not
	@param mine : Mine
	@return boolean
--]]
local function isMineCovered(mine)
	--'mine' can be a function value from Grid
	if typeof(mine) ~= "table" then
		warn("Invalid Parameter Given")
		return false
	end
	if mine.isVisible or mine.Flagged then
		return false
	end
	

	return true
end

local function getNeighbors(pos : Vector3) : {Vector3}
	local neighbors = {}
	
	for x = pos.X - 1, pos.X + 1, 1 do
		for y = pos.Y - 1, pos.Y + 1, 1 do
			for z = pos.Z - 1, pos.Z + 1, 1 do
				local position = Vector3.new(x, y, z)	
				
				if pos ~= position and isValidPos(position) then
					table.insert(neighbors, position)
				end
			end
		end
	end 
	
	return neighbors
end

--[[End of local functions]]


--[[Start of global functions]]

--[[
	Places the number of appropriate mines into an evenly spaced grid.
	@param
	@return
--]]
function grid:placeCells()
	
	local totalSpace = upperbounds - lowerbounds
	local paddingVector = Vector3.new(PADDING, PADDING, PADDING)
	local cellSize = (totalSpace -((OBJECTS + Vector3.new(1,1,1)) * (paddingVector))) / OBJECTS
	
	if cellSize.X <= 0 or cellSize.Y <= 0 or cellSize.Z <= 0 then
		warn("The given grid is too small for the number of objects given.", "The cell size is ", tostring(cellSize))
	end	
	
	for x = 1, OBJECTS.X do
		for y = 1, OBJECTS.Y do
			for z = 1, OBJECTS.Z do
				local index = Vector3.new(x, y, z)
				--local sizePos = ((index + Vector3.new(.5,.5,.5)) * cellSize)
				
				local pos = (paddingVector * index) + (cellSize / 2) + ((index - Vector3.one) * cellSize) + lowerbounds
				local cf = CFrame.new(pos)
				
				local name = tostring(x) .." " .. tostring(y) .. " " .. tostring(z)
				
				local mine = mine.new()		

				local part = mine.Part
				part.CFrame = cf
				part.Size = cellSize
				part.Name = name

				part.Transparency = 0
				part.Parent = gridFolder
				mine.Part = part
				
				Mines[x][y][z] = self._janitor:Add(mine, "Destroy")

			end
		end
	end
	
	generateBombs()
	
end


function grid:determineNearestMine(pos : Vector3) : Vector3?
	--I could offset the position by the lowerbounds, and then divide by the total size of cell, and then round to get the cell. 
	local totalSpace = upperbounds - lowerbounds
	local offset = pos - lowerbounds

	local paddingVector = Vector3.new(PADDING, PADDING, PADDING)
	local cellSize = (totalSpace -((OBJECTS + Vector3.new(1,1,1)) * (paddingVector))) / OBJECTS

	--if offset.X == 0 or offset.Y == 0 or offset.Z == 0 then
	--	warn("Division by zero would have occured. Terminating thread")
	--	return;
	--end

	local cellMath = offset / cellSize + Vector3.new(.0001, .0001, .0001)
	local cell = Vector3.new(
		math.ceil(cellMath.X),
		math.ceil(cellMath.Y),
		math.ceil(cellMath.Z)
	)
	
	if isValidPos(cell) then
		return cell
	end
	
	warn("Unable to determine the nearest mine. Terminating thread")
	return nil;	
end
--[[
	Switches a mine's visibility and handles all of the behind the scenes of flagging.
	@param mousePos : Vector3
	@return 
--]]
function grid:uncoverMineAtMousePos(mousePos : Vector3)
	local pos = self:determineNearestMine(mousePos); if not pos then return end
	
	self:uncoverMineAtCell(pos)
end

function grid:uncoverMineAtCell(pos : Vector3)
	local mine = self:getMine(pos); if not mine then return end;

	if mine.Flagged or mine.isVisible then
		return
	end

	if mine.Bomb then
		visuals.playerLose(mine)
		return
	end

	
	mine.isVisible = true

	if (mine.Neighbors == 0) then
		--Autoremove adjacent cells
		local neighbors = getNeighbors(pos)
		for i, v in pairs(neighbors) do
			self:uncoverMineAtCell(v)
		end
	end

	----Fire visual script
	visuals.UpdateMines(mine)
end


--[[
	Returns the mine at a certain position
	@param pos : vector3
	@return Mine
	
]]
function grid:getMine(pos : Vector3)
	return Mines[pos.X][pos.Y][pos.Z]
end

--[[
	Toggle flag for the cell
	@param pos
	@return
--]]
function grid:FlagMine(pos : Vector3)
	local position = self:determineNearestMine(pos)
	
	if position == nil then
		return
	end
	
	local mine = self:getMine(position)
	print(mine.Part:GetFullName())

	if not mine.isVisible then
		mine.Flagged = not mine.Flagged
		visuals.flagMine(mine)
	end
end

--[[
	Determines the number of non-visible mines left. 
	@param
	@return int
--]]
function grid:getNumberOfCoveredCells()
	local count = 0
	
	for x = 1,  #Mines do
		for y = 1, #Mines[x] do
			for z = 1, #Mines[x][y] do
				if isMineCovered(Mines[x][y][z]) then
					count += 1
				end
			end
		end		
	end

	return count
end



function grid:squashThirdDimension() 
	OBJECTS.Y = 1
end

function grid:getSize() : Vector3
	return OBJECTS
end
--[[
	Creates a new Grid object. Contains all properties of Grid, and also contains all mines in a grid.
	@param
	@return Grid
--]]
function grid.new()
--create grid
	return setmetatable({
		_janitor = Janitor.new(),
	}, grid)

end



--[[
	Clean up grid. Ends up cleaning up all 'Mine' objects as well.
	@param
	@return
]]
function grid:Destroy()
	print("Destroying Grid")
	local janitor = self._janitor
	

	if janitor then
		janitor:Destory()
		self._janitor = nil
	end
end

--function grid:GetCenter() : Vector3
--	return center
--end


--[[End of global functions]]


--[[
If I want to transform this script to allow for 3d, what I could do is 
I can also set up inheritance, so that I can have all forms of grids inherit similar structure.
]]

return grid