Unity3D best way to create editable voxel environment

I want to create a dynamic voxel environment for a Minecraft like game. My main language is Java, however since I didn't want to write a game entirely from scratch I decided to go with Unity3D. I read this tutorial to learn about the topic: http://alexstv.com/index.php/category/voxels

I have an environment up and running and have included my own FPS collector. However, my next goal now is to reduce the block sizes. Basically, I want to split each cube into a different 8x8x8 editable surface. This would provide much more flexibility for the entire world. In the Block class, I can get the individual blocks to appear smaller using Block.blockSize. BUT, there are gaps between blocks and between chunks when I do this. So obviously I'm missing something, but I'm not sure what. I guess I will be looking for what determines the distance between blocks and blocks in this code.

Also I thought that maybe just increase the character to become a giant .. again not sure if this is the best course.

Here is my Block class:

using UnityEngine;
using System.Collections;
using System;

[Serializable]
public class Block
{
    public enum Direction { north, east, south, west, up, down };


    public struct Tile { public int x; public int y;}



    const float tileSize = 0.25f;
    const float blockSize = 0.5f;
    const int blockSpace = 1;

    public bool changed = true;

    //Base block constructor
    public Block()
    {

    }

    public virtual MeshData Blockdata
        (Chunk chunk, int x, int y, int z, MeshData meshData)
    {


        meshData.useRenderDataForCol = true;

        if (!chunk.GetBlock(x, y + blockSpace, z).IsSolid(Direction.down))
        {
            meshData = FaceDataUp(chunk, x, y, z, meshData);
        }

        if (!chunk.GetBlock(x, y - blockSpace, z).IsSolid(Direction.up))
        {
            meshData = FaceDataDown(chunk, x, y, z, meshData);
        }

        if (!chunk.GetBlock(x, y, z +blockSpace).IsSolid(Direction.south))
        {
            meshData = FaceDataNorth(chunk, x, y, z, meshData);
        }

        if (!chunk.GetBlock(x, y, z - blockSpace).IsSolid(Direction.north))
        {
            meshData = FaceDataSouth(chunk, x, y, z, meshData);
        }

        if (!chunk.GetBlock(x + blockSpace, y, z).IsSolid(Direction.west))
        {
            meshData = FaceDataEast(chunk, x, y, z, meshData);
        }

        if (!chunk.GetBlock(x - blockSpace, y, z).IsSolid(Direction.east))
        {
            meshData = FaceDataWest(chunk, x, y, z, meshData);
        }

        return meshData;

    }





    protected virtual MeshData FaceDataUp
        (Chunk chunk, int x, int y, int z, MeshData meshData)
    {

        meshData.AddVertex(new Vector3(x - blockSize, y + blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y + blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y + blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y + blockSize, z - blockSize));

        meshData.AddQuadTriangles();
        meshData.uv.AddRange(FaceUVs(Direction.up));
        return meshData;
    }

    protected virtual MeshData FaceDataDown
        (Chunk chunk, int x, int y, int z, MeshData meshData)
    {
        meshData.AddVertex(new Vector3(x - blockSize, y - blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y - blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y - blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y - blockSize, z + blockSize));

        meshData.AddQuadTriangles();
        meshData.uv.AddRange(FaceUVs(Direction.down));
        return meshData;
    }

    protected virtual MeshData FaceDataNorth
        (Chunk chunk, int x, int y, int z, MeshData meshData)
    {
        meshData.AddVertex(new Vector3(x + blockSize, y - blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y + blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y + blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y - blockSize, z + blockSize));

        meshData.AddQuadTriangles();
        meshData.uv.AddRange(FaceUVs(Direction.north));
        return meshData;
    }

    protected virtual MeshData FaceDataEast
        (Chunk chunk, int x, int y, int z, MeshData meshData)
    {
        meshData.AddVertex(new Vector3(x + blockSize, y - blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y + blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y + blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y - blockSize, z + blockSize));

        meshData.AddQuadTriangles();
        meshData.uv.AddRange(FaceUVs(Direction.east));
        return meshData;
    }

    protected virtual MeshData FaceDataSouth
        (Chunk chunk, int x, int y, int z, MeshData meshData)
    {
        meshData.AddVertex(new Vector3(x - blockSize, y - blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y + blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y + blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x + blockSize, y - blockSize, z - blockSize));

        meshData.AddQuadTriangles();
        meshData.uv.AddRange(FaceUVs(Direction.south));
        return meshData;
    }

    protected virtual MeshData FaceDataWest
        (Chunk chunk, int x, int y, int z, MeshData meshData)
    {
        meshData.AddVertex(new Vector3(x - blockSize, y - blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y + blockSize, z + blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y + blockSize, z - blockSize));
        meshData.AddVertex(new Vector3(x - blockSize, y - blockSize, z - blockSize));

        meshData.AddQuadTriangles();
        meshData.uv.AddRange(FaceUVs(Direction.west));
        return meshData;
    }

    public virtual Tile TexturePosition(Direction direction)
    {
        Tile tile = new Tile();
        tile.x = 0;
        tile.y = 0;

        return tile;
    }

    public virtual Vector2[] FaceUVs(Direction direction)
    {
        Vector2[] UVs = new Vector2[4];
        Tile tilePos = TexturePosition(direction);

        UVs[0] = new Vector2(tileSize * tilePos.x + tileSize,
            tileSize * tilePos.y);
        UVs[1] = new Vector2(tileSize * tilePos.x + tileSize,
            tileSize * tilePos.y + tileSize);
        UVs[2] = new Vector2(tileSize * tilePos.x,
            tileSize * tilePos.y + tileSize);
        UVs[3] = new Vector2(tileSize * tilePos.x,
            tileSize * tilePos.y);

        return UVs;
    }

    public virtual bool IsSolid(Direction direction)
    {
        switch (direction)
        {
            case Direction.north:
                return true;
            case Direction.east:
                return true;
            case Direction.south:
                return true;
            case Direction.west:
                return true;
            case Direction.up:
                return true;
            case Direction.down:
                return true;
        }

        return false;
    }

}

      

        
        
        
      

    

World class:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class World : MonoBehaviour {

    public Dictionary<WorldPos, Chunk> chunks = new Dictionary<WorldPos, Chunk>();
    public GameObject chunkPrefab;

    public string worldName = "world";

    public void CreateChunk(int x, int y, int z)
    {
        WorldPos worldPos = new WorldPos(x, y, z);

        //Instantiate the chunk at the coordinates using the chunk prefab
        GameObject newChunkObject = Instantiate(
                        chunkPrefab, new Vector3(x, y, z),
                        Quaternion.Euler(Vector3.zero)
                    ) as GameObject;

        Chunk newChunk = newChunkObject.GetComponent<Chunk>();

        newChunk.pos = worldPos;
        newChunk.world = this;

        //Add it to the chunks dictionary with the position as the key
        chunks.Add(worldPos, newChunk);

        var terrainGen = new TerrainGen();
        newChunk = terrainGen.ChunkGen(newChunk);

        newChunk.SetBlocksUnmodified();

        Serialization.Load(newChunk);
    }

    public void DestroyChunk(int x, int y, int z)
    {
        Chunk chunk = null;
        if (chunks.TryGetValue(new WorldPos(x, y, z), out chunk))
        {
            Serialization.SaveChunk(chunk);
            Object.Destroy(chunk.gameObject);
            chunks.Remove(new WorldPos(x, y, z));
        }
    }

    public Chunk GetChunk(int x, int y, int z)
    {
        WorldPos pos = new WorldPos();
        float multiple = Chunk.chunkSize;
        pos.x = Mathf.FloorToInt(x / multiple) * Chunk.chunkSize;
        pos.y = Mathf.FloorToInt(y / multiple) * Chunk.chunkSize;
        pos.z = Mathf.FloorToInt(z / multiple) * Chunk.chunkSize;

        Chunk containerChunk = null;

        chunks.TryGetValue(pos, out containerChunk);

        return containerChunk;
    }

    public Block GetBlock(int x, int y, int z)
    {
        Chunk containerChunk = GetChunk(x, y, z);

        if (containerChunk != null)
        {
            Block block = containerChunk.GetBlock(
                x - containerChunk.pos.x,
                y - containerChunk.pos.y,
                z - containerChunk.pos.z);

            return block;
        }
        else
        {
            return new BlockAir();
        }

    }

    public void SetBlock(int x, int y, int z, Block block)
    {
        Chunk chunk = GetChunk(x, y, z);

        if (chunk != null)
        {
            chunk.SetBlock(x - chunk.pos.x, y - chunk.pos.y, z - chunk.pos.z, block);
            chunk.update = true;

            UpdateIfEqual(x - chunk.pos.x, 0, new WorldPos(x - 1, y, z));
            UpdateIfEqual(x - chunk.pos.x, Chunk.chunkSize - 1, new WorldPos(x + 1, y, z));
            UpdateIfEqual(y - chunk.pos.y, 0, new WorldPos(x, y - 1, z));
            UpdateIfEqual(y - chunk.pos.y, Chunk.chunkSize - 1, new WorldPos(x, y + 1, z));
            UpdateIfEqual(z - chunk.pos.z, 0, new WorldPos(x, y, z - 1));
            UpdateIfEqual(z - chunk.pos.z, Chunk.chunkSize - 1, new WorldPos(x, y, z + 1));

        }
    }

    void UpdateIfEqual(int value1, int value2, WorldPos pos)
    {
        if (value1 == value2)
        {
            Chunk chunk = GetChunk(pos.x, pos.y, pos.z);
            if (chunk != null)
                chunk.update = true;
        }
    }
}

      

        
        
        
      

    

If you need any more code or information, please let me know!

I am also open to suggestions for other better engines or techniques to use here!