3DnRaya check

    -----Check winner or tie ----
                function board.check_all()
                    local c_turn = board.player[board.turn].st --Save the str of the current player in a variable
                    --Fisrt check winner
                    for i = board.row, board.row do
                        if board.check._2D_horizontal(c_turn,i) or board.check._2D_vertical(c_turn,i) or --2D
                            board.check._2D_diagonal_inc(c_turn,i) or board.check._2D_diagonal_dec(c_turn,i) or --2D DIAGONALS
                            board.check._3D_horizontal_up(c_turn,i) or board.check._3D_vertical_up(c_turn,i) or --3d UP
                            board.check._3D_horizontal_down(c_turn,i) or board.check._3D_vertical_down(c_turn,i) or --3D DOWN
                            board.check._3D_diagonal_inc_up(c_turn,i) or board.check._3D_diagonal_dec_up(c_turn,i) or --3D DIAGONALS UP
                            board.check._3D_diagonal_inc_down(c_turn,i) or board.check._3D_diagonal_dec_down(c_turn,i) or --3D DIAGONALS DOWN
                            board.check._3D_vertical(c_turn,i) --3D VERTICAL

                            then
                            board.win = board.turn
                        else board.win = false
                        end
                    end
                end

------------------------------------2D FUNCTIONS------------------------------------
    ----- 2D-Check vertical ----
                function board.check._2D_vertical(str,n)
                    local cont, tab = 1,{}
                    for d = 1, board.depth do  --The depth
                        for x = 1, board.width do
                            for y = 1, board.height do
                                tab ={} --Empty the tab
                                cont = 1  --Reset the counter
                                if board.table[d][y][x] == str then  --If the current chip is the
                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                    for i = 1, n do
                                        if board.inside(x,y+i) and board.table[d][y+i][x] == str then
                                            cont = cont +1
                                            table.insert(tab,{x=x,y=y+i,d=d})
                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                        if cont >= n then
                                            board.winner_row.vars.initx = x
                                            board.winner_row.vars.inity = y
                                            board.winner_row.vars.initd = d
                                            board.winner_row.vars.finald = d
                                            board.winner_row.vars.finalx = x
                                            board.winner_row.vars.finaly = y+i
                                            board.winner_row.row = tab
                                            board.winner_row.vars.how = "vertical"
                                            return true
                                        end
                                    end
                                end
                            end
                        end
                    end
                end

    -----2D-Check horizontal ----
                function board.check._2D_horizontal(str,n)
                    local cont, tab = 1,{}
                    for d = 1, board.depth do  --The depth
                        for y = 1, board.height do
                            for x = 1, board.width do
                                tab ={} --Empty the tab
                                cont = 1  --Reset the counter
                                if board.table[d][y][x] == str then  --If the current chip is the
                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                    for i = 1, n do
                                        if board.inside(x+i,y) and board.table[d][y][x+i] == str then
                                            cont = cont +1
                                            table.insert(tab,{x=x+i,y=y,d=d})
                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                        if cont >= n then
                                            board.winner_row.vars.initx = x
                                            board.winner_row.vars.inity = y
                                            board.winner_row.vars.initd = d
                                            board.winner_row.vars.finald = d
                                            board.winner_row.vars.finalx = x+i
                                            board.winner_row.vars.finaly = y
                                            board.winner_row.row = tab
                                            board.winner_row.vars.how = "horizontal"
                                            return true
                                        end
                                    end
                                end
                            end
                        end
                    end
                end

    -----2D-Check diagonal with y increasing ----
                function board.check._2D_diagonal_inc(str,n)
                    local cont, tab = 1,{}
                    for d = 1, board.depth do  --The depth
                        for y = 1, board.height do
                            for x = 1, board.width do
                                tab ={} --Empty the tab
                                cont = 1  --Reset the counter
                                if board.table[d][y][x] == str then  --If the current chip is the
                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                    for i = 1, n do
                                        if board.inside(x+i,y+i) and board.table[d][y+i][x+i] == str then
                                            cont = cont +1
                                            table.insert(tab,{x=x+i,y=y+i,d=d})
                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                        if cont >= n then
                                            board.winner_row.vars.initx = x
                                            board.winner_row.vars.inity = y
                                            board.winner_row.vars.initd = d
                                            board.winner_row.vars.finald = d
                                            board.winner_row.vars.finalx = x+i
                                            board.winner_row.vars.finaly = y+i
                                            board.winner_row.row = tab
                                            board.winner_row.vars.how = "diagonal_inc"
                                            return true
                                        end
                                    end
                                end
                            end
                        end
                    end
                end

    -----2D-Check diagonal with y decreasing ----
                function board.check._2D_diagonal_dec(str,n)
                    local cont, tab = 1,{}
                    for d = 1, board.depth do  --The depth
                        for y = 1, board.height do
                            for x = 1, board.width do
                                tab ={} --Empty the tab
                                cont = 1  --Reset the counter
                                if board.table[d][y][x] == str then  --If the current chip is the
                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                    for i = 1, n do
                                        if board.inside(x+i,y-i) and board.table[d][y-i][x+i] == str then
                                            cont = cont +1
                                            table.insert(tab,{x=x+i,y=y-i,d=d})
                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                        if cont >= n then
                                            board.winner_row.vars.initx = x
                                            board.winner_row.vars.inity = y
                                            board.winner_row.vars.initd = d
                                            board.winner_row.vars.finald = d
                                            board.winner_row.vars.finalx = x+i
                                            board.winner_row.vars.finaly = y-i
                                            board.winner_row.row = tab
                                            board.winner_row.vars.how = "diagonal_dec"
                                            return true
                                        end
                                    end
                                end
                            end
                        end
                    end
                end

------------------------------------3D FUNCTIONS------------------------------------
----------------------  UP
                    ----- 3D-Check vertical UP----
                                function board.check._3D_vertical_up(str,n)
                                    local cont, tab = 1,{}
                                    for d = 1, board.depth do  --The depth
                                        for x = 1, board.width do
                                            for y = 1, board.height do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x,y+i,d+i) and board.table[d+i][y+i][x] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x,y=y+i,d=d+i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d+i
                                                            board.winner_row.vars.finalx = x
                                                            board.winner_row.vars.finaly = y+i
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "vertical"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end

                    -----3D-Check horizontal UP----
                                function board.check._3D_horizontal_up(str,n)
                                    local cont, tab = 1,{}
                                    for d = 1, board.depth do  --The depth
                                        for y = 1, board.height do
                                            for x = 1, board.width do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x+i,y,d+i) and board.table[d+i][y][x+i] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x+i,y=y,d=d+i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d+i
                                                            board.winner_row.vars.finalx = x+i
                                                            board.winner_row.vars.finaly = y
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "horizontal"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end

                    -----3D-Check diagonal with y increasing UP----
                                function board.check._3D_diagonal_inc_up(str,n)
                                    local cont, tab = 1,{}
                                    for d = 1, board.depth do  --The depth
                                        for y = 1, board.height do
                                            for x = 1, board.width do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x+i,y+i,d+i) and board.table[d+i][y+i][x+i] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x+i,y=y+i,d=d+i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d+i
                                                            board.winner_row.vars.finalx = x+i
                                                            board.winner_row.vars.finaly = y+i
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "diagonal_inc"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end

                    -----3D-Check diagonal with y decreasing UP ----
                                function board.check._3D_diagonal_dec_up(str,n)
                                    local cont, tab = 1,{}
                                    for d = 1, board.depth do  --The depth
                                        for y = 1, board.height do
                                            for x = 1, board.width do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x+i,y-i,d+i) and board.table[d+i][y-i][x+i] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x+i,y=y-i,d=d+i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d+i
                                                            board.winner_row.vars.finalx = x+i
                                                            board.winner_row.vars.finaly = y-i
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "diagonal_dec"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end


----------------------  DOWN
                    ----- 3D-Check vertical DOWN----
                                function board.check._3D_vertical_down(str,n)
                                    local cont, tab = 1,{}
                                    for d = board.depth,1,-1 do  --The depth
                                        for x = 1, board.width do
                                            for y = 1, board.height do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x,y+i,d-i) and board.table[d-i][y+i][x] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x,y=y+i,d=d-i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d-i
                                                            board.winner_row.vars.finalx = x
                                                            board.winner_row.vars.finaly = y+i
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "vertical"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end

                    -----3D-Check horizontal DOWN----
                                function board.check._3D_horizontal_down(str,n)
                                    local cont, tab = 1,{}
                                    for d = board.depth,1,-1 do  --The depth
                                        for y = 1, board.height do
                                            for x = 1, board.width do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x+i,y,d-i) and board.table[d-i][y][x+i] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x+i,y=y,d=d-i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d-i
                                                            board.winner_row.vars.finalx = x+i
                                                            board.winner_row.vars.finaly = y
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "horizontal"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end

                    -----3D-Check diagonal with y increasing DOWN----
                                function board.check._3D_diagonal_inc_down(str,n)
                                    local cont, tab = 1,{}
                                    for d = board.depth,1,-1 do  --The depth
                                        for y = 1, board.height do
                                            for x = 1, board.width do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x+i,y+i,d-i) and board.table[d-i][y+i][x+i] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x+i,y=y+i,d=d-i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d-i
                                                            board.winner_row.vars.finalx = x+i
                                                            board.winner_row.vars.finaly = y+i
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "diagonal_inc"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end

                    -----3D-Check diagonal with y decreasing DOWN ----
                                function board.check._3D_diagonal_dec_down(str,n)
                                    local cont, tab = 1,{}
                                    for d = board.depth,1,-1 do  --The depth
                                        for y = 1, board.height do
                                            for x = 1, board.width do
                                                tab ={} --Empty the tab
                                                cont = 1  --Reset the counter
                                                if board.table[d][y][x] == str then  --If the current chip is the
                                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                                    for i = 1, n do
                                                        if board.inside(x+i,y-i,d-i) and board.table[d-i][y-i][x+i] == str then
                                                            cont = cont +1
                                                            table.insert(tab,{x=x+i,y=y-i,d=d-i})
                                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                                        if cont >= n then
                                                            board.winner_row.vars.initx = x
                                                            board.winner_row.vars.inity = y
                                                            board.winner_row.vars.initd = d
                                                            board.winner_row.vars.finald = d-i
                                                            board.winner_row.vars.finalx = x+i
                                                            board.winner_row.vars.finaly = y-i
                                                            board.winner_row.row = tab
                                                            board.winner_row.vars.how = "diagonal_dec"
                                                            return true
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end



    ----- 3D-Check vertical ----
                function board.check._3D_vertical(str,n)
                    local cont, tab = 1,{}
                    for d = 1, board.depth do  --The depth
                        for x = 1, board.width do
                            for y = 1, board.height do
                                tab ={} --Empty the tab
                                cont = 1  --Reset the counter
                                if board.table[d][y][x] == str then  --If the current chip is the
                                    table.insert(tab,{x=x,y=y,d=d}) --Insert the postion in the array
                                    for i = 1, n do
                                        if board.inside(x,y,d+i) and board.table[d+i][y][x] == str then
                                            cont = cont +1
                                            table.insert(tab,{x=x,y=y,d=d+i})
                                        end --If the position+i is the str then increase the cont var and insert the postion in the array
                                        if cont >= n then
                                            board.winner_row.vars.initx = x
                                            board.winner_row.vars.inity = y
                                            board.winner_row.vars.initd = d
                                            board.winner_row.vars.finald = d+i
                                            board.winner_row.vars.finalx = x
                                            board.winner_row.vars.finaly = y
                                            board.winner_row.row = tab
                                            board.winner_row.vars.how = "vertical"
                                            return true
                                        end
                                    end
                                end
                            end
                        end
                    end
                end