Exemplo n.º 1
0
    void DrawWireFrame()
    {
        WireFrameHelper.render = false;
        int cubeLayerIndex        = LayerMask.NameToLayer("Chunk");
        int otherPlayerLayerIndex = LayerMask.NameToLayer("OtherPlayer");
        int plantLayerIndex       = LayerMask.NameToLayer("Plant");

        if (cubeLayerIndex != -1 && otherPlayerLayerIndex != -1 && plantLayerIndex != -1)
        {
            int layerMask = 1 << cubeLayerIndex | 1 << otherPlayerLayerIndex | 1 << plantLayerIndex;
            if (Physics.Raycast(Camera.main.ScreenPointToRay(center), out hit, 5f, layerMask))
            {
                if (hit.transform.gameObject.layer == cubeLayerIndex || hit.transform.gameObject.layer == plantLayerIndex)
                {
                    Vector3Int pos = Vector3Int.RoundToInt(hit.point - hit.normal / 100);
                    NBTHelper.GetBlockData(pos.x, pos.y, pos.z, out byte type, out byte data);
                    if (type != 0)
                    {
                        if (pos != WireFrameHelper.pos)
                        {
                            breakingTime = 0;
                        }

                        WireFrameHelper.render    = true;
                        WireFrameHelper.pos       = pos;
                        WireFrameHelper.hitPos    = hit.point;
                        WireFrameHelper.type      = type;
                        WireFrameHelper.data      = data;
                        WireFrameHelper.generator = NBTGeneratorManager.GetMeshGenerator(type);
                    }
                }
            }
        }
    }
Exemplo n.º 2
0
    public override void OnRightClick()
    {
        bool isUpper = (WireFrameHelper.data & 0b1000) > 0;

        int  direction = 0;
        bool isOpen    = false;

        if (isUpper)
        {
            NBTHelper.GetBlockData(WireFrameHelper.pos.x, WireFrameHelper.pos.y - 1, WireFrameHelper.pos.z, out byte belowType, out byte belowData);
            if (belowType == 64)
            {
                isOpen    = (belowData & 0b0100) > 0;
                direction = belowData & 0b0011;
            }

            byte newData = (byte)(belowData ^ 0b0100);
            NBTHelper.SetBlockData(WireFrameHelper.pos + Vector3Int.down, WireFrameHelper.type, newData);
        }
        else
        {
            isOpen = (WireFrameHelper.data & 0b0100) > 0;

            byte newData = (byte)(WireFrameHelper.data ^ 0b0100);
            NBTHelper.SetBlockData(WireFrameHelper.pos, WireFrameHelper.type, newData);
        }
        SoundManager.Play2DSound(isOpen ? "Player_Door_Close" : "Player_Door_Open");

        NBTChunk chunk = NBTHelper.GetChunk(WireFrameHelper.pos);

        chunk.RebuildMesh(UpdateFlags.Collidable);
    }
Exemplo n.º 3
0
    public static void Init()
    {
        TagNodeCompound player   = NBTHelper.GetPlayerData();
        int             gameMode = player["playerGameType"] as TagNodeInt;

        _mode = (GameMode)gameMode;
    }
Exemplo n.º 4
0
    public override void OnAddBlock(RaycastHit hit)
    {
        Vector3Int pos = WireFrameHelper.pos + Vector3Int.RoundToInt(hit.normal);

        if (CanAddBlock(pos))
        {
            PlayerController.instance.PlayHandAnimation();

            byte type = NBTGeneratorManager.id2type[id];
            byte data = (byte)InventorySystem.items[ItemSelectPanel.curIndex].damage;

            if (hit.normal == Vector3.up || hit.normal == Vector3.down)
            {
                data |= 0b0000;
            }
            else if (hit.normal == Vector3.left || hit.normal == Vector3.right)
            {
                data |= 0b0100;
            }
            else if (hit.normal == Vector3.back || hit.normal == Vector3.forward)
            {
                data |= 0b1000;
            }
            NBTHelper.SetBlockData(pos, type, data);

            InventorySystem.DecrementCurrent();
            ItemSelectPanel.instance.RefreshUI();
        }
    }
Exemplo n.º 5
0
 void OnClickQuit()
 {
     NBTHelper.Save();
     LocalServer.SaveData();
     NetworkManager.Clear();
     SceneManager.LoadScene("LoginScene");
 }
Exemplo n.º 6
0
    //input is local position
    public void GetBlockData(int xInChunk, int worldY, int zInChunk, out byte blockType, out byte blockData)
    {
        blockType = 0;
        blockData = 0;
        if (worldY < 0 || worldY > 255)
        {
            return;
        }

        if (xInChunk < 0 || xInChunk > 15 || zInChunk < 0 || zInChunk > 15)
        {
            NBTHelper.GetBlockData(xInChunk + 16 * x, worldY, zInChunk + 16 * z, out blockType, out blockData);
            return;
        }

        int sectionIndex = Mathf.FloorToInt(worldY / 16f);

        if (sectionIndex >= 0 && sectionIndex < Sections.Count)
        {
            TagNodeCompound  section = Sections[sectionIndex] as TagNodeCompound;
            TagNodeByteArray blocks  = section["Blocks"] as TagNodeByteArray;
            TagNodeByteArray data    = section["Data"] as TagNodeByteArray;

            int yInSection = worldY - sectionIndex * 16;
            int blockPos   = yInSection * 16 * 16 + zInChunk * 16 + xInChunk;

            if (blockPos >= 0 && blockPos < 4096)
            {
                blockType = blocks.Data[blockPos];
                blockData = NBTHelper.GetNibble(data.Data, blockPos);
                return;
            }
        }
        return;
    }
Exemplo n.º 7
0
    public static void Update()
    {
        UnityEngine.Profiling.Profiler.BeginSample("ChunkChecker.Update");

        if (isRefreshing)
        {
            return;
        }

        Vector2Int curChunk = PlayerController.GetCurrentChunkPos();

        // if player moved to another chunk or render distance is changed, then try to refresh chunks data.
        if (lastChunk != curChunk || lastRenderDistance != SettingsPanel.RenderDistance)
        {
            isRefreshing       = true;
            tmpChunk           = curChunk;
            lastRenderDistance = SettingsPanel.RenderDistance;

            // only load chunks in render distance (if render distance is greater than 6, then load chunks in 6)
            // and unload chunks out of render distance
            List <Vector2Int> loadChunks   = NBTHelper.GetLoadChunks(curChunk);
            List <Vector2Int> unloadChunks = NBTHelper.GetUnloadChunks(curChunk, SettingsPanel.RenderDistance);

            if (loadChunks.Count > 0 || unloadChunks.Count > 0)
            {
                ChunkManager.ChunksEnterLeaveViewReq(loadChunks, unloadChunks);
            }
            else
            {
                FinishRefresh();
            }
        }

        UnityEngine.Profiling.Profiler.EndSample();
    }
Exemplo n.º 8
0
    bool CanAddBlock(Vector3Int pos)
    {
        NBTBlock generator = NBTGeneratorManager.GetMeshGenerator(InventorySystem.items[ItemSelectPanel.curIndex].id);

        // 手上的
        if (generator == null)
        {
            return(false);
        }

        byte     type            = NBTHelper.GetBlockByte(pos);
        NBTBlock targetGenerator = NBTGeneratorManager.GetMeshGenerator(type);

        if (generator is NBTPlant)
        {
            if (generator == targetGenerator)
            {
                return(false);
            }

            byte belowType = NBTHelper.GetBlockByte(pos + Vector3Int.down);

            //如果手上拿的是植物,则判断下方是否是否是实体
            NBTBlock targetBelowGenerator = NBTGeneratorManager.GetMeshGenerator(belowType);
            return(targetBelowGenerator != null && !(targetBelowGenerator is NBTPlant));
        }
        else
        {
            //如果手上拿的不是植物,则判断碰撞盒是否与玩家相交
            return(!cc.bounds.Intersects(new Bounds(pos, Vector3.one)));
        }
    }
Exemplo n.º 9
0
 public static void ShowBlock(NBTObject generator, short data)
 {
     instance.handMeshRenderer.enabled   = false;
     instance.blockMeshFilter.sharedMesh = generator.GetItemMesh(NBTHelper.GetChunk(GetCurrentBlock()), (byte)data);
     instance.blockMeshRenderer.GetComponent <MeshRenderer>().sharedMaterial = generator.GetItemMaterial((byte)data);
     instance.blockMeshFilter.transform.gameObject.SetActive(true);
 }
Exemplo n.º 10
0
    void InitTileEntity()
    {
        if (hasInitTileEntity)
        {
            return;
        }

        foreach (Vector3Int pos in tileEntityList)
        {
            if (!tileEntityObjs.ContainsKey(pos))
            {
                int              sectionIndex = pos.y / 16;
                TagNodeCompound  Section      = Sections[sectionIndex] as TagNodeCompound;
                TagNodeByteArray Blocks       = Section["Blocks"] as TagNodeByteArray;
                TagNodeByteArray Data         = Section["Data"] as TagNodeByteArray;

                int        yInSection = pos.y % 16;
                int        blockPos   = yInSection * 16 * 16 + pos.z * 16 + pos.x;
                byte       rawType    = Blocks.Data[blockPos];
                NBTBlock   generator  = NBTGeneratorManager.GetMeshGenerator(rawType);
                byte       blockData  = NBTHelper.GetNibble(Data.Data, blockPos);
                GameObject obj        = generator.GetTileEntityGameObject(this, blockData, pos);

                tileEntityObjs[pos] = obj;
            }
        }

        hasInitTileEntity = true;
    }
Exemplo n.º 11
0
    // Update is called once per frame
    void Update()
    {
        Vector3    pos      = PlayerController.instance.transform.position;
        Vector3Int curBlock = PlayerController.GetCurrentBlock();

        int chunkX   = Mathf.FloorToInt(curBlock.x / 16f);
        int chunkY   = Mathf.FloorToInt(curBlock.y / 16f);
        int chunkZ   = Mathf.FloorToInt(curBlock.z / 16f);
        int xInChunk = curBlock.x - chunkX * 16;
        int yInChunk = curBlock.y - chunkY * 16;
        int zInChunk = curBlock.z - chunkZ * 16;

        Vector3Int posInt = pos.ToVector3Int();

        NBTHelper.GetLightsByte(posInt.x, posInt.y, posInt.z, out byte skyLight, out byte blockLight);
        byte maxLight = skyLight > blockLight ? skyLight : blockLight;

        UnityEngine.Profiling.Profiler.BeginSample("zstring");
        using (zstring.Block())
        {
            zstring text = zstring.Format(template, Application.version, GetFPS(), pos.x, pos.y, pos.z, curBlock.x, curBlock.y, curBlock.z);
            text += zstring.Format(template2, xInChunk, yInChunk, zInChunk, chunkX, chunkY, chunkZ, maxLight, skyLight, blockLight);
            if (WireFrameHelper.render)
            {
                text += zstring.Format(template3, WireFrameHelper.pos.x, WireFrameHelper.pos.y, WireFrameHelper.pos.z, WireFrameHelper.generator.name, WireFrameHelper.data);
            }
            label.text = text;

            label2.text = ChunkRefresher.GetChunkUpdatesCount() + (zstring)" chunk updates";
        }
        UnityEngine.Profiling.Profiler.EndSample();
    }
Exemplo n.º 12
0
 private void OnDestroy()
 {
     ChunkPool.Uninit();
     InputManager.Destroy();
     UISystem.DestroyUIRoot();
     PlayerController.Destroy();
     NBTHelper.Uninit();
 }
Exemplo n.º 13
0
 public static void PreloadChunks(List <Vector2Int> enterViewChunks)
 {
     foreach (Vector2Int chunkPos in enterViewChunks)
     {
         NBTChunk chunk = NBTHelper.LoadChunk(chunkPos.x, chunkPos.y);
         ChunkRefresher.Add(chunk);
     }
     ChunkRefresher.ForceRefreshAll();
 }
Exemplo n.º 14
0
    public void GetLightsByte(int xInChunk, int yInChunk, int zInChunk, out byte skyLight, out byte blockLight, bool extends = false)
    {
        skyLight   = 15;
        blockLight = 0;
        if (xInChunk < 0 || xInChunk > 15 || zInChunk < 0 || zInChunk > 15)
        {
            if (extends)
            {
                int xOffset = 0;
                int zOffset = 0;

                if (xInChunk < 0)
                {
                    xOffset = -1;
                }
                else if (xInChunk > 15)
                {
                    xOffset = 1;
                }

                if (zInChunk < 0)
                {
                    zOffset = -1;
                }
                else if (zInChunk > 15)
                {
                    zOffset = 1;
                }

                NBTChunk chunk = NBTHelper.GetChunk(x + xOffset, z + zOffset);
                if (chunk != null)
                {
                    chunk.GetLightsByte(xInChunk - xOffset * 16, yInChunk, zInChunk - zOffset * 16, out skyLight, out blockLight);
                }
            }
            return;
        }

        int sectionIndex = yInChunk / 16;

        if (sectionIndex >= Sections.Count || yInChunk < 0 || yInChunk > 255)
        {
            return;
        }

        int yInSection = yInChunk % 16;
        int blockPos   = yInSection * 16 * 16 + zInChunk * 16 + xInChunk;

        TagNodeCompound  Section  = Sections[sectionIndex] as TagNodeCompound;
        TagNodeByteArray SkyLight = Section["SkyLight"] as TagNodeByteArray;

        skyLight = NBTHelper.GetNibble(SkyLight.Data, blockPos);
        TagNodeByteArray BlockLight = Section["BlockLight"] as TagNodeByteArray;

        blockLight = NBTHelper.GetNibble(BlockLight.Data, blockPos);
    }
Exemplo n.º 15
0
    static void Single_OnLoginReq(object obj, Action <object> callback)
    {
        CSLoginReq req = obj as CSLoginReq;

        Vector3 pos = NBTHelper.GetPlayerPos();
        Vector3 rot = NBTHelper.GetPlayerRot();

        CSLoginRes rsp = new CSLoginRes()
        {
            RetCode    = 0,
            PlayerData = new CSPlayer
            {
                PlayerID    = 0,
                Name        = "Steve",
                Position    = pos.ToCSVector3(),
                Rotation    = rot.ToCSVector3(),
                SelectIndex = playerData.SelectIndex,
            }
        };

        for (int i = 0; i < 18; i++)
        {
            rsp.PlayerData.BagItems.Add(new CSItem {
                Type  = playerData.BagItems[i].type,
                Count = playerData.BagItems[i].count
            });
        }

        for (int i = 0; i < 9; i++)
        {
            rsp.PlayerData.SelectItems.Add(new CSItem
            {
                Type  = playerData.SelectItems[i].type,
                Count = playerData.SelectItems[i].count
            });
        }

        foreach (KeyValuePair <Vector3Int, Vector3Int> kvPair in dependenceDict)
        {
            rsp.BlockAttrs.Add(new CSBlockAttrs {
                pos       = kvPair.Key.ToCSVector3Int(),
                depentPos = kvPair.Value.ToCSVector3Int(),
            });
        }

        foreach (KeyValuePair <Vector3Int, CSBlockOrientation> kvPair in orientationDict)
        {
            rsp.BlockAttrs.Add(new CSBlockAttrs
            {
                pos    = kvPair.Key.ToCSVector3Int(),
                orient = kvPair.Value,
            });
        }

        callback(rsp);
    }
Exemplo n.º 16
0
    private void Start()
    {
        instance = this;

        TagNodeCompound levelDat    = NBTHelper.GetLevelDat();
        TagNodeLong     dayTimeNode = levelDat["DayTime"] as TagNodeLong;
        int             dayTime     = (int)dayTimeNode.Data;

        tick = dayTime;
    }
Exemplo n.º 17
0
 void OnClickSingle()
 {
     DataCenter.name          = "Steve";
     DataCenter.spawnPosition = NBTHelper.GetPlayerPos();
     DataCenter.spawnRotation = NBTHelper.GetPlayerRot();
     MainMenu.Close();
     LoadingUI.Show();
     SceneManager.LoadScene("GameScene");
     //ChatPanel.AddLine(DataCenter.name + ", welcome!");
 }
Exemplo n.º 18
0
    public override void OnDestroyBlock(Vector3Int globalPos, byte blockData)
    {
        bool isUpper = (blockData & 0b1000) > 0;

        if (isUpper)
        {
            NBTHelper.SetBlockByteNoUpdate(globalPos - Vector3Int.up, 0);
        }
        else
        {
            NBTHelper.SetBlockByteNoUpdate(globalPos + Vector3Int.up, 0);
        }
    }
Exemplo n.º 19
0
 public static void ShowBlock(NBTObject generator, short data)
 {
     instance.handMeshRenderer.enabled = false;
     try
     {
         instance.blockMeshFilter.sharedMesh = generator.GetItemMesh(NBTHelper.GetChunk(GetCurrentBlock()), Vector3Int.RoundToInt(instance.position), (byte)data);
     }
     catch (System.Exception e)
     {
         Debug.LogError("showblock error, generator=" + generator + ",message=\n" + e.Message);
     }
     instance.blockMeshRenderer.GetComponent <MeshRenderer>().sharedMaterial = generator.GetItemMaterial((byte)data);
     instance.blockMeshFilter.transform.gameObject.SetActive(true);
 }
Exemplo n.º 20
0
    //input is local position
    public void GetBlockData(int xInChunk, int worldY, int zInChunk, ref byte blockType, ref byte blockData)
    {
        if (xInChunk < 0 || xInChunk > 15 || worldY < 0 || worldY > 255 || zInChunk < 0 || zInChunk > 15)
        {
            //if (xInChunk < 0)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x - 1, z);
            //    chunk.GetBlockData(xInChunk + 16, worldY, zInChunk, ref blockType, ref blockData);
            //}
            //else if (xInChunk > 15)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x + 1, z);
            //    chunk.GetBlockData(xInChunk - 16, worldY, zInChunk, ref blockType, ref blockData);
            //}
            //else if (zInChunk < 0)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x, z - 1);
            //    chunk.GetBlockData(xInChunk, worldY, zInChunk + 16, ref blockType, ref blockData);
            //}
            //else if (zInChunk > 15)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x, z + 1);
            //    chunk.GetBlockData(xInChunk, worldY, zInChunk - 16, ref blockType, ref blockData);
            //}

            //NBTHelper.GetBlockData(xInChunk + 16 * x, worldY, zInChunk + 16 * z, ref blockType, ref blockData);
            return;
        }

        int sectionIndex = Mathf.FloorToInt(worldY / 16f);

        if (sectionIndex >= 0 && sectionIndex < Sections.Count)
        {
            TagNodeCompound  section = Sections[sectionIndex] as TagNodeCompound;
            TagNodeByteArray blocks  = section["Blocks"] as TagNodeByteArray;
            TagNodeByteArray data    = section["Data"] as TagNodeByteArray;

            int yInSection = worldY - sectionIndex * 16;
            int blockPos   = yInSection * 16 * 16 + zInChunk * 16 + xInChunk;

            if (blockPos >= 0 && blockPos < 4096)
            {
                blockType = blocks.Data[blockPos];
                blockData = NBTHelper.GetNibble(data.Data, blockPos);
                return;
            }
        }
        return;
    }
Exemplo n.º 21
0
    public virtual void OnAddBlock(RaycastHit hit)
    {
        Vector3Int pos = WireFrameHelper.pos + Vector3Int.RoundToInt(hit.normal);

        if (CanAddBlock(pos))
        {
            PlayerController.instance.PlayHandAnimation();

            byte type = NBTGeneratorManager.id2type[id];
            byte data = (byte)InventorySystem.items[ItemSelectPanel.curIndex].damage;
            NBTHelper.SetBlockData(pos, type, data);

            InventorySystem.DecrementCurrent();
            ItemSelectPanel.instance.RefreshUI();
        }
    }
Exemplo n.º 22
0
 public static void ChunksEnterLeaveViewReq(List <Vector2Int> enterViewChunks, List <Vector2Int> leaveViewChunks = null)
 {
     foreach (Vector2Int chunkPos in enterViewChunks)
     {
         NBTChunk chunk = NBTHelper.LoadChunk(chunkPos.x, chunkPos.y);
         ChunkRefresher.Add(chunk);
     }
     if (leaveViewChunks != null)
     {
         foreach (Vector2Int chunk in leaveViewChunks)
         {
             UnloadChunk(chunk.x, chunk.y);
         }
     }
     ChunkChecker.FinishRefresh();
 }
Exemplo n.º 23
0
    protected void InitData()
    {
        NBTChunk chunk = NBTHelper.GetChunk(pos);

        if (chunk != null && chunk.tileEntityDict.ContainsKey(pos))
        {
            Items = (TagNodeList)chunk.tileEntityDict[pos]["Items"];
            foreach (TagNodeCompound item in Items)
            {
                byte slot = item["Slot"] as TagNodeByte;
                InventorySystem.items[slot + 46].id     = item["id"] as TagNodeString;
                InventorySystem.items[slot + 46].damage = item["Damage"] as TagNodeShort;
                InventorySystem.items[slot + 46].count  = item["Count"] as TagNodeByte;
            }
        }
    }
Exemplo n.º 24
0
    public static void RespawnRefreshChunks()
    {
        var preloadChunks = Utilities.GetSurroudingChunks(PlayerController.GetCurrentChunkPos(), 1);
        var unloadChunks  = chunkDict.Keys.Except(preloadChunks).ToList();

        foreach (Vector2Int chunk in unloadChunks)
        {
            NBTHelper.RemoveChunk(chunk.x, chunk.y);
        }
        foreach (Vector2Int chunkPos in preloadChunks)
        {
            NBTChunk chunk = NBTHelper.LoadChunk(chunkPos.x, chunkPos.y);
            ChunkRefresher.Add(chunk);
        }
        ChunkRefresher.ForceRefreshAll();
    }
Exemplo n.º 25
0
    // Start is called before the first frame update
    void Start()
    {
        shadowTrans = transform.Find("shadow");
        shadow      = shadowTrans.GetComponent <Renderer>().material;

        meshTrans = transform.Find("mesh_parent/mesh");
        MeshFilter meshFilter = meshTrans.GetComponent <MeshFilter>();

        Vector3Int pos = Vector3Int.RoundToInt(transform.position);

        meshFilter.sharedMesh           = generator.GetItemMesh(NBTHelper.GetChunk(PlayerController.GetCurrentBlock()), pos, blockData);
        meshFilter.transform.localScale = generator.itemSize;

        meshTrans.GetComponent <MeshRenderer>().sharedMaterial = generator.GetItemMaterial(blockData);

        RefreshMesh();
    }
Exemplo n.º 26
0
    void BreakBlock(Vector3Int pos)
    {
        if (Time.time - lastBreakTime < 0.1f)
        {
            return;
        }
        lastBreakTime = Time.time;

        breakingTime = 0;

        HideBreakingEffect();
        //DeleteBlockReq(WireFrameHelper.pos);

        NBTBlock generator = WireFrameHelper.generator;

        if (generator.hasDropItem)
        {
            try
            {
                string id   = generator.GetDropItemByData(WireFrameHelper.data);
                byte   data = generator.GetDropItemData(WireFrameHelper.data);
                Item.CreateBlockDropItem(id, data, pos);
            }
            catch (System.Exception e)
            {
                Debug.LogError("create item error, id=" + generator.GetDropItemByData(WireFrameHelper.data) + ",generator=" + generator);
            }
        }
        generator.OnDestroyBlock(WireFrameHelper.pos, WireFrameHelper.data);

        if (generator.isTileEntity)
        {
            NBTChunk chunk = NBTHelper.GetChunk(WireFrameHelper.pos);
            chunk.RemoveTileEntity(WireFrameHelper.pos);
            NBTHelper.SetBlockByteNoUpdate(WireFrameHelper.pos, 0);
        }
        else
        {
            NBTHelper.SetBlockByte(WireFrameHelper.pos, 0);
        }


        //Item.CreateBlockDropItem(type, WireFrameHelper.pos);
        BreakBlockEffect.Create(WireFrameHelper.type, WireFrameHelper.data, WireFrameHelper.pos);
        SoundManager.PlayBreakSound(WireFrameHelper.type, instance.gameObject);
    }
Exemplo n.º 27
0
    public void Respawn()
    {
        TagNodeCompound player = NBTHelper.GetPlayerData();
        int             x      = player["SpawnX"] as TagNodeInt;
        int             y      = player["SpawnY"] as TagNodeInt;
        int             z      = player["SpawnZ"] as TagNodeInt;

        Vector3 spawnVec = new Vector3(x, y, z);

        transform.position = spawnVec;
        lastPosOnGround    = spawnVec;

        NBTHelper.RespawnRefreshChunks();

        Time.timeScale = 1;
        Health         = 20;
    }
Exemplo n.º 28
0
    //input is local position
    public byte GetBlockByte(int xInChunk, int worldY, int zInChunk)
    {
        if (xInChunk < 0 || xInChunk > 15 || zInChunk < 0 || zInChunk > 15)
        {
            //if (xInChunk < 0)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x - 1, z);
            //    return chunk.GetBlockByte(xInChunk + 16, worldY, zInChunk);
            //}
            //else if (xInChunk > 15)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x + 1, z);
            //    return chunk.GetBlockByte(xInChunk - 16, worldY, zInChunk);
            //}
            //else if (zInChunk < 0)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x, z - 1);
            //    return chunk.GetBlockByte(xInChunk, worldY, zInChunk + 16);
            //}
            //else if (zInChunk > 15)
            //{
            //    NBTChunk chunk = NBTHelper.GetChunk(x, z + 1);
            //    return chunk.GetBlockByte(xInChunk, worldY, zInChunk - 16);
            //}

            return(NBTHelper.GetBlockByte(xInChunk + 16 * x, worldY, zInChunk + 16 * z));
        }

        int sectionIndex = Mathf.FloorToInt(worldY / 16f);

        if (sectionIndex >= 0 && sectionIndex < Sections.Count)
        {
            TagNodeCompound  section = Sections[sectionIndex] as TagNodeCompound;
            TagNodeByteArray blocks  = section["Blocks"] as TagNodeByteArray;

            int yInSection = worldY - sectionIndex * 16;
            int blockPos   = yInSection * 16 * 16 + zInChunk * 16 + xInChunk;

            if (blockPos >= 0 && blockPos < 4096)
            {
                return(blocks.Data[blockPos]);
            }
        }
        return(0);
    }
Exemplo n.º 29
0
    public static void Init()
    {
        TagNodeCompound playerData = NBTHelper.GetPlayerData();
        TagNodeList     Inventory  = playerData["Inventory"] as TagNodeList;

        for (int i = 0; i < Inventory.Count; i++)
        {
            TagNodeCompound item   = Inventory[i] as TagNodeCompound;
            byte            slot   = item["Slot"] as TagNodeByte;
            byte            count  = item["Count"] as TagNodeByte;
            short           damage = item["Damage"] as TagNodeShort;
            string          id     = item["id"] as TagNodeString;

            items[slot].id     = id;
            items[slot].count  = count;
            items[slot].damage = damage;
        }
    }
Exemplo n.º 30
0
    // Start is called before the first frame update
    void Start()
    {
        shadowTrans = transform.Find("shadow");
        shadow      = shadowTrans.GetComponent <Renderer>().material;

        meshTrans = transform.Find("mesh_parent/mesh");
        MeshFilter meshFilter = meshTrans.GetComponent <MeshFilter>();

        meshFilter.sharedMesh = generator.GetItemMesh(NBTHelper.GetChunk(PlayerController.GetCurrentBlock()), blockData);
        if (generator is NBTBlock && !(generator is NBTPlant))
        {
            meshFilter.transform.localScale = Vector3.one / 2;
        }

        meshTrans.GetComponent <MeshRenderer>().sharedMaterial = generator.GetItemMaterial(blockData);

        RefreshMesh();
    }