protected virtual bool CheckNeedBuilFaceForCubeHalf(DirectionEnum faceDirection, BlockMetaCubeHalf blockMeta, BlockMetaCubeHalf blockMetaClose)
    {
        DirectionEnum halfPosition      = blockMeta.GetHalfPosition();
        DirectionEnum halfPositionClose = blockMetaClose.GetHalfPosition();

        switch (faceDirection)
        {
        case DirectionEnum.Down:
            if (halfPosition == DirectionEnum.UP)
            {
                return(true);
            }
            else
            {
                switch (halfPositionClose)
                {
                case DirectionEnum.Down:
                    return(true);

                case DirectionEnum.UP:
                    return(false);

                case DirectionEnum.Left:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Right:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Forward:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Back:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                default:
                    return(false);
                }
            }

        case DirectionEnum.UP:
            if (halfPosition == DirectionEnum.Down)
            {
                return(true);
            }
            else
            {
                switch (halfPositionClose)
                {
                case DirectionEnum.Down:
                    return(false);

                case DirectionEnum.UP:
                    return(true);

                case DirectionEnum.Left:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Right:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Forward:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Back:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                default:
                    return(false);
                }
            }

        case DirectionEnum.Left:
            if (halfPosition == DirectionEnum.Right)
            {
                return(true);
            }
            else
            {
                switch (halfPositionClose)
                {
                case DirectionEnum.Down:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.UP:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Left:
                    return(true);

                case DirectionEnum.Right:
                    return(false);

                case DirectionEnum.Forward:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Back:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                default:
                    return(false);
                }
            }

        case DirectionEnum.Right:
            if (halfPosition == DirectionEnum.Left)
            {
                return(true);
            }
            else
            {
                switch (halfPositionClose)
                {
                case DirectionEnum.Down:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.UP:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Left:
                    return(false);

                case DirectionEnum.Right:
                    return(true);

                case DirectionEnum.Forward:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Back:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                default:
                    return(false);
                }
            }

        case DirectionEnum.Forward:
            if (halfPosition == DirectionEnum.Back)
            {
                return(true);
            }
            else
            {
                switch (halfPositionClose)
                {
                case DirectionEnum.Down:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.UP:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Left:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Right:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Forward:
                    return(true);

                case DirectionEnum.Back:
                    return(false);

                default:
                    return(false);
                }
            }

        case DirectionEnum.Back:
            if (halfPosition == DirectionEnum.Forward)
            {
                return(true);
            }
            else
            {
                switch (halfPositionClose)
                {
                case DirectionEnum.Down:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.UP:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Left:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Right:
                    if (halfPosition == halfPositionClose)
                    {
                        return(false);
                    }
                    else
                    {
                        return(true);
                    }

                case DirectionEnum.Forward:
                    return(false);

                case DirectionEnum.Back:
                    return(true);

                default:
                    return(false);
                }
            }

        default:
            return(false);
        }
    }
Esempio n. 2
0
    public override void ItemUse(
        Vector3Int targetWorldPosition, BlockDirectionEnum targetBlockDirection, Block targetBlock, Chunk targetChunk,
        Vector3Int closeWorldPosition, BlockDirectionEnum closeBlockDirection, Block closeBlock, Chunk closeChunk,
        BlockDirectionEnum direction, string metaData)
    {
        //如果同样是半砖 并且是同一种类
        if (targetBlock.blockInfo.GetBlockShape() == BlockShapeEnum.CubeHalf && targetBlock.blockType == blockType)
        {
            BlockBean         targetBlockData = targetChunk.GetBlockData(targetWorldPosition - targetChunk.chunkData.positionForWorld);
            BlockMetaCubeHalf targetMetaData  = targetBlockData.GetBlockMeta <BlockMetaCubeHalf>();
            BlockMetaCubeHalf curMetaData     = FromMetaData <BlockMetaCubeHalf>(metaData);

            DirectionEnum targetHalfPosition = targetMetaData.GetHalfPosition();
            DirectionEnum curHalfPosition    = curMetaData.GetHalfPosition();
            bool          isMerge            = false;
            switch (targetHalfPosition)
            {
            case DirectionEnum.UP:
                if (curHalfPosition == DirectionEnum.UP)
                {
                    isMerge = true;
                }
                break;

            case DirectionEnum.Down:
                if (curHalfPosition == DirectionEnum.Down)
                {
                    isMerge = true;
                }
                break;

            case DirectionEnum.Left:
                if (curHalfPosition == DirectionEnum.Left)
                {
                    isMerge = true;
                }
                break;

            case DirectionEnum.Right:
                if (curHalfPosition == DirectionEnum.Right)
                {
                    isMerge = true;
                }
                break;

            case DirectionEnum.Forward:
                if (curHalfPosition == DirectionEnum.Forward)
                {
                    isMerge = true;
                }
                break;

            case DirectionEnum.Back:
                if (curHalfPosition == DirectionEnum.Back)
                {
                    isMerge = true;
                }
                break;
            }
            if (isMerge)
            {
                targetChunk.SetBlockForWorld(targetWorldPosition, (BlockTypeEnum)blockInfo.remark_int, BlockDirectionEnum.UpForward);
            }
            else
            {
                base.ItemUse(targetWorldPosition, targetBlockDirection, targetBlock, targetChunk, closeWorldPosition, closeBlockDirection, closeBlock, closeChunk, direction, metaData);
            }
        }
        else
        {
            base.ItemUse(targetWorldPosition, targetBlockDirection, targetBlock, targetChunk, closeWorldPosition, closeBlockDirection, closeBlock, closeChunk, direction, metaData);
        }
    }