Exemple #1
0
        public void ShowBlockInventory(BlocksPlayer playerUsing, LVector3 block)
        {
            Inventory   blockInventory;
            BlockOrItem customBlock;

            if (blocksWorld.world.BlockHasInventory(block, out blockInventory) && blocksWorld.blocksPack.customBlocks.ContainsKey(block.BlockV, out customBlock))
            {
                ShowPlayerInventory(playerUsing);
                blockShowing          = block;
                blockShowingInventory = blockInventory;
                blocksWorld.otherObjectInventoryGui.displaying               = true;
                blocksWorld.otherObjectInventoryGui.playerUsing              = playerUsing;
                blocksWorld.otherObjectInventoryGui.inventory                = blockInventory;
                blocksWorld.otherObjectInventoryGui.inventory                = blockInventory;
                blocksWorld.otherObjectInventoryGui.screenOffset             = new Vector2(0, 300);
                blocksWorld.otherObjectInventoryGui.customBlockOwner         = customBlock;
                blocksWorld.otherObjectInventoryGui.customBlockOwnerPosition = block;
                blocksWorld.otherObjectInventoryGui.numRows = customBlock.NumInventoryRows();
                showingInventory      = true;
                showingBlockInventory = true;
            }
            else
            {
                HidePlayerInventory();
                blockShowing          = LVector3.Invalid;
                blockShowingInventory = null;
                showingBlockInventory = false;
                showingInventory      = false;
            }
        }
Exemple #2
0
 public void ShowPlayerInventory(BlocksPlayer player)
 {
     activeGuiPlayer        = player;
     showingInventory       = true;
     showingBlockInventory  = false;
     playerInventoryShowing = player;
     playerInventoryShowing.inventoryGui.maxItems       = -1;
     playerInventoryShowing.inventoryGui.numRows        = 4;
     playerInventoryShowing.inventoryGui.screenOffset.y = -Screen.height / 2.0f + 300.0f;
     playerInventoryShowing.inventoryGui.inventory      = player.inventory;
     playerInventoryShowing.inventoryGui.playerUsing    = playerInventoryShowing;
     playerInventoryShowing.inventoryGui.enabled        = true;
 }
Exemple #3
0
        private void Update()
        {
            if (inventory != null && menuManager.CurrentMenu != MenuManager.MenuStatus.BlockInventory && menuManager.CurrentMenu != MenuManager.MenuStatus.Inventory && !menuManager.paused && customBlockOwnerPosition != LVector3.Invalid && customBlockOwner != null)
            {
                if (customBlockOwner.ReturnsItemsWhenDeselected() && playerUsing != null)
                {
                    for (int i = 0; i < inventory.blocks.Length; i++)
                    {
                        if (inventory.blocks[i].Block != BlockValue.Air && inventory.blocks[i].count > 0)
                        {
                            if (playerUsing.inventory.CanAddBlock(inventory.blocks[i]))
                            {
                                if (playerUsing.inventory.TryToAddBlock(inventory.blocks[i]))
                                {
                                }
                                else
                                {
                                    World.mainWorld.CreateBlockEntity(inventory.blocks[i], (new LVector3(0, 1, 0) + customBlockOwnerPosition).BlockCentertoUnityVector3());
                                }
                                inventory.blocks[i] = new BlockStack(BlockValue.Air, 0);
                            }
                        }
                    }
                    playerUsing              = null;
                    customBlockOwner         = null;
                    customBlockOwnerPosition = LVector3.Invalid;
                }
            }


            if (inventory == null || !displaying || playerUsing == null)
            {
                hasInventory = false;
            }
            if (!displaying || playerUsing == null)
            {
                for (int i = 0; i < blockItems.Count; i++)
                {
                    GameObject.Destroy(blockItems[i].gameObject);
                }
                blockItems.Clear();
                return;
            }

            if (!hasInventory && inventory != null && displaying && playerUsing != null)
            {
                hasInventory = true;
                CallInventoryModifiedCallbacks();
            }



            if (selection < 0)
            {
                selection = 0;
            }
            int actualMaxItems = inventory.capacity;

            if (maxItems != -1)
            {
                actualMaxItems = Mathf.Min(maxItems, actualMaxItems);
            }
            if (selection > actualMaxItems - 1)
            {
                selection = actualMaxItems - 1;
            }

            ShowInventory(numRows, maxItems);

            if (playerUsing.mouseLook.allowedToCapture)
            {
                if (HoldingSomethingWithMouse())
                {
                    ThrowStuff();
                }
                return;
            }



            bool inventoryModified = false;

            // click when not capturing
            if (!HoldingSomethingWithMouse())
            {
                if (Input.GetMouseButtonDown(0) && displaying)
                {
                    for (int i = 0; i < blockItems.Count; i++)
                    {
                        if (i < inventory.blocks.Length)
                        {
                            //Debug.Log("trying "  + i + " " + inventory.blocks[i] + " " + name);
                            if (MouseIntersectsBlockEntity(blockItems[i]) && !IsEmptyBlockStack(inventory.blocks[i]))
                            {
                                //Debug.Log("got dat boi");
                                playerUsing.blocksHoldingWithMouse       = inventory.blocks[i].Copy();
                                playerUsing.holdingWithMouseEntity       = MakeNewBlockEntity(inFront: true);
                                playerUsing.holdingWithMouseEntity.Stack = inventory.blocks[i];
                                inventory.blocks[i] = new BlockStack(BlockValue.Air, 0);
                                inventoryModified   = true;
                                //playerUsing.mouseLook.allowedToCapture = false;
                                break;
                            }
                        }
                        else
                        {
                            int ind = i - inventory.blocks.Length;
                            //Debug.Log("trying "  + i + " " + inventory.blocks[i] + " " + name);
                            if (MouseIntersectsBlockEntity(blockItems[i]) && !IsEmptyBlockStack(inventory.resultBlocks[ind]))
                            {
                                //Debug.Log("got dat boi");
                                playerUsing.blocksHoldingWithMouse       = inventory.resultBlocks[ind].Copy();
                                playerUsing.holdingWithMouseEntity       = MakeNewBlockEntity(inFront: true);
                                playerUsing.holdingWithMouseEntity.Stack = inventory.resultBlocks[ind].Copy();
                                inventory.resultBlocks[ind] = new BlockStack(BlockValue.Air, 0);
                                inventoryModified           = true;
                                //playerUsing.mouseLook.allowedToCapture = false;
                                break;
                            }
                        }
                    }
                }
            }

            else if (HoldingSomethingWithMouse() && playerUsing.holdingWithMouseEntity != null && displaying)
            {
                int prevCount = playerUsing.blocksHoldingWithMouse.count;
                //player.mouseLook.allowedToCapture = false;
                //Vector3 offset;
                //Ray ray = playerUsing.mainCamera.ScreenPointToRay(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0.1f));
                playerUsing.holdingWithMouseEntity.transform.localPosition = new Vector3(Input.mousePosition.x - Screen.width / 2.0f, Input.mousePosition.y - Screen.height / 2.0f, -0.02f);
                if (Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1))
                {
                    //bool foundCollision = false;
                    for (int i = 0; i < blockItems.Count; i++)
                    {
                        if (i < inventory.blocks.Length)
                        {
                            if (MouseIntersectsBlockEntity(blockItems[i]))
                            {
                                //foundCollision = true;
                                bool letGo = false;
                                if (IsEmptyBlockStack(inventory.blocks[i]))
                                {
                                    // right click, drop one
                                    if (Input.GetMouseButtonDown(1))
                                    {
                                        inventory.blocks[i]       = playerUsing.blocksHoldingWithMouse.Copy();
                                        inventory.blocks[i].count = 1;
                                        inventoryModified         = true;
                                        if (playerUsing.blocksHoldingWithMouse.count == 1)
                                        {
                                            letGo = true;
                                        }
                                        else
                                        {
                                            playerUsing.blocksHoldingWithMouse.count -= 1;
                                        }
                                    }
                                    // left click, put all
                                    else if (Input.GetMouseButtonDown(0))
                                    {
                                        inventory.blocks[i] = playerUsing.blocksHoldingWithMouse.Copy();
                                        inventoryModified   = true;
                                        letGo = true;
                                    }
                                }
                                else
                                {
                                    if (inventory.blocks[i].block == playerUsing.blocksHoldingWithMouse.block)
                                    {
                                        int numMaxStack = 1;
                                        if (World.stackableSize.ContainsKey(playerUsing.blocksHoldingWithMouse.block))
                                        {
                                            numMaxStack = World.stackableSize[playerUsing.blocksHoldingWithMouse.block];
                                        }
                                        // right click, drop one
                                        if (Input.GetMouseButtonDown(1))
                                        {
                                            // can fit some in, put 1 in
                                            if (inventory.blocks[i].count < numMaxStack)
                                            {
                                                // we are only holding one, put it all in
                                                if (playerUsing.blocksHoldingWithMouse.count == 1)
                                                {
                                                    inventory.blocks[i].count += playerUsing.blocksHoldingWithMouse.count;
                                                    inventoryModified          = true;
                                                    letGo = true;
                                                    playerUsing.blocksHoldingWithMouse = new BlockStack(BlockValue.Air, 0);
                                                }
                                                // put 1 in and leave rest of stack in hand
                                                else
                                                {
                                                    inventory.blocks[i].count += 1;
                                                    inventoryModified          = true;
                                                    playerUsing.blocksHoldingWithMouse.count -= 1;
                                                    if (playerUsing.blocksHoldingWithMouse.count <= 0)
                                                    {
                                                        Debug.LogError("we should have count > 0 when not putting all (right click and we have more than 1 put only put 1 in) into block, got count " + playerUsing.blocksHoldingWithMouse.count + " instead");
                                                    }
                                                }
                                            }
                                        }
                                        // left click, place all sorta
                                        else if (Input.GetMouseButtonDown(0))
                                        {
                                            // can fit some in
                                            if (inventory.blocks[i].count < numMaxStack)
                                            {
                                                // can fit all in
                                                if (inventory.blocks[i].count + playerUsing.blocksHoldingWithMouse.count <= numMaxStack)
                                                {
                                                    inventory.blocks[i].count += playerUsing.blocksHoldingWithMouse.count;
                                                    inventoryModified          = true;
                                                    letGo = true;
                                                    playerUsing.blocksHoldingWithMouse = new BlockStack(BlockValue.Air, 0);
                                                }
                                                // can only fit some in
                                                else
                                                {
                                                    int numCanFitIn = numMaxStack - inventory.blocks[i].count;
                                                    inventory.blocks[i].count += numCanFitIn;
                                                    inventoryModified          = true;
                                                    playerUsing.blocksHoldingWithMouse.count -= numCanFitIn;
                                                    if (playerUsing.blocksHoldingWithMouse.count <= 0)
                                                    {
                                                        Debug.LogError("we should have count > 0 when not putting all into block, got count " + playerUsing.blocksHoldingWithMouse.count + " instead");
                                                    }
                                                }
                                            }
                                            // can't fit any more in, swap
                                            else
                                            {
                                                inventory.blocks[i].count = playerUsing.blocksHoldingWithMouse.count;
                                                inventoryModified         = true;
                                                playerUsing.blocksHoldingWithMouse.count = numMaxStack;
                                            }
                                        }
                                    }
                                    // different things, swap
                                    else if (Input.GetMouseButtonDown(0))
                                    {
                                        BlockStack tmp = inventory.blocks[i].Copy();
                                        inventory.blocks[i] = playerUsing.blocksHoldingWithMouse.Copy();
                                        inventoryModified   = true;
                                        playerUsing.blocksHoldingWithMouse       = tmp;
                                        playerUsing.holdingWithMouseEntity.Stack = tmp;
                                    }
                                }
                                if (letGo)
                                {
                                    playerUsing.blocksHoldingWithMouse = new BlockStack(BlockValue.Air, 0);
                                    GameObject.Destroy(playerUsing.holdingWithMouseEntity.gameObject);
                                    playerUsing.holdingWithMouseEntity = null;
                                    //mouseLook.allowedToCapture = true;
                                }
                            }
                        }
                        // result blocks
                        else
                        {
                            int ind = i - inventory.blocks.Length;
                            //Debug.Log("trying "  + i + " " + inventory.blocks[i] + " " + name);
                            if (MouseIntersectsBlockEntity(blockItems[i]) && !IsEmptyBlockStack(inventory.resultBlocks[ind]))
                            {
                                // only work if we add the whole stack to it
                                if (playerUsing.blocksHoldingWithMouse.TryToAddToStack(inventory.resultBlocks[ind]))
                                {
                                    inventory.resultBlocks[ind] = new BlockStack(BlockValue.Air, 0);
                                    inventoryModified           = true;

                                    //playerUsing.mouseLook.allowedToCapture = false;
                                    break;
                                }
                            }
                        }
                    }
                    // didn't click on anything, threw on ground instead
                    //if (!foundCollision)
                    //{
                    //    ThrowStuff();
                    //}
                }


                if (!IsEmptyBlockStack(playerUsing.blocksHoldingWithMouse) && prevCount != playerUsing.blocksHoldingWithMouse.count)
                {
                    playerUsing.holdingWithMouseEntity.blockStack.count = playerUsing.blocksHoldingWithMouse.count;
                }
            }

            if (HoldingSomethingWithMouse() && displaying && playerUsing.holdingWithMouseEntity != null)
            {
                //player.mouseLook.allowedToCapture = false;
                //Vector3 offset;
                //Ray ray = playerUsing.mainCamera.ScreenPointToRay(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0.1f));
                playerUsing.holdingWithMouseEntity.transform.localPosition = new Vector3(Input.mousePosition.x - Screen.width / 2.0f, Input.mousePosition.y - Screen.height / 2.0f, -0.02f);
            }


            if (inventoryModified)
            {
                CallInventoryModifiedCallbacks();
            }
        }
Exemple #4
0
        // Update is called once per frame
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.Escape))
            {
                paused = true;
                ShowPauseMenu();
            }
            if (paused)
            {
                allowedToCapture = false;
                if (smoothMouseLook != null)
                {
                    smoothMouseLook.allowedToCapture = allowedToCapture;
                }
                return;
            }

            if (!showingInventory)
            {
                showingBlockInventory = false;
            }

            if (showingInventory)
            {
                allowedToCapture = false;
            }
            else if (!paused)
            {
                allowedToCapture = true;
            }

            if (smoothMouseLook != null)
            {
                smoothMouseLook.allowedToCapture = allowedToCapture;
            }



            curMenuStatus = CurrentMenu;

            // in world
            if (blocksWorld != null && smoothMouseLook != null)
            {
                // if the current gui player is disabled, we need to search for which one we are actually using
                if (activeGuiPlayer == null || !activeGuiPlayer.enabled)
                {
                    activeGuiPlayer = null;
                    foreach (BlocksPlayer player in FindObjectsOfType <BlocksPlayer>())
                    {
                        if (player.enabled)
                        {
                            activeGuiPlayer = player;
                            break;
                        }
                    }
                    if (activeGuiPlayer != null)
                    {
                        smoothMouseLook = activeGuiPlayer.GetComponent <SmoothMouseLook>();
                    }
                }

                if (curMenu == MenuStatus.LoadWorld || curMenu == MenuStatus.GenerateWorld || curMenu == MenuStatus.MainMenu)
                {
                    curMenu               = MenuStatus.Hotbar;
                    showingInventory      = false;
                    showingBlockInventory = false;
                    paused = false;
                }
                if (curMenuStatus != MenuStatus.BlockInventory && curMenuStatus != MenuStatus.Inventory)
                {
                    if (playerInventoryShowing != null)
                    {
                        playerInventoryShowing.inventoryGui.displaying = false;
                        playerInventoryShowing = null;
                    }
                    if (blockShowing != LVector3.Invalid || blockShowingInventory != null)
                    {
                        blocksWorld.otherObjectInventoryGui.displaying  = false;
                        blocksWorld.otherObjectInventoryGui.playerUsing = null;
                        blocksWorld.otherObjectInventoryGui.inventory   = null;
                        blockShowingInventory = null;
                        blockShowing          = LVector3.Invalid;
                    }
                }

                if (curMenuStatus == MenuStatus.Inventory)
                {
                    if (playerInventoryShowing == null)
                    {
                        blocksWorld.otherObjectInventoryGui.displaying  = false;
                        blocksWorld.otherObjectInventoryGui.playerUsing = null;
                    }
                }


                if (curMenuStatus == MenuStatus.Hotbar)
                {
                    playerHotbarShowing = activeGuiPlayer;
                    playerHotbarShowing.inventoryGui.numRows        = 1;
                    playerHotbarShowing.inventoryGui.inventory      = playerHotbarShowing.inventory;
                    playerHotbarShowing.inventoryGui.maxItems       = playerHotbarShowing.hotbarSize;
                    playerHotbarShowing.inventoryGui.screenOffset.y = -Screen.height / 2.0f + 100.0f;
                    playerHotbarShowing.inventoryGui.displaying     = true;
                }
                else
                {
                    if (playerHotbarShowing != null)
                    {
                        //playerHotbarShowing.inventoryGui.displaying = false;
                        //playerHotbarShowing = null;
                    }
                }
            }
            // in main menu
            else
            {
                if (curMenuStatus == MenuStatus.Hotbar || curMenuStatus == MenuStatus.Inventory || curMenuStatus == MenuStatus.BlockInventory)
                {
                    curMenu = MenuStatus.MainMenu;
                }
            }


            if (CurrentMenu == MenuStatus.Hotbar)
            {
                HideAllMenus();
            }
        }