예제 #1
0
 public override void Update()
 {
     if (m_slider1.IsSliding)
     {
         m_maxExtension = (int)m_slider1.Value - 1;
     }
     if (m_slider2.IsSliding)
     {
         m_pullCount = (int)m_slider2.Value - 1;
     }
     if (m_slider3.IsSliding)
     {
         m_speed = (int)m_slider3.Value;
     }
     if (m_okButton.IsClicked)
     {
         int value = PistonBlock.SetMaxExtension(PistonBlock.SetPullCount(PistonBlock.SetSpeed(m_data, m_speed), m_pullCount), m_maxExtension);
         Dismiss(value);
     }
     if (base.Input.Cancel || m_cancelButton.IsClicked)
     {
         Dismiss(null);
     }
     UpdateControls();
 }
예제 #2
0
        public void MovingBlocksCollidedWithTerrain(IMovingBlockSet movingBlockSet, Point3 p)
        {
            if (!(movingBlockSet.Id == "Piston"))
            {
                return;
            }
            Point3 point     = (Point3)movingBlockSet.Tag;
            int    cellValue = m_subsystemTerrain.Terrain.GetCellValue(point.X, point.Y, point.Z);

            if (Terrain.ExtractContents(cellValue) != 237)
            {
                return;
            }
            Point3 point2 = CellFace.FaceToPoint3(PistonBlock.GetFace(Terrain.ExtractData(cellValue)));
            int    num    = p.X * point2.X + p.Y * point2.Y + p.Z * point2.Z;
            int    num2   = point.X * point2.X + point.Y * point2.Y + point.Z * point2.Z;

            if (num > num2)
            {
                if (IsBlockBlocking(base.SubsystemTerrain.Terrain.GetCellValue(p.X, p.Y, p.Z)))
                {
                    movingBlockSet.Stop();
                }
                else
                {
                    base.SubsystemTerrain.DestroyCell(0, p.X, p.Y, p.Z, 0, noDrop: false, noParticleSystem: false);
                }
            }
        }
예제 #3
0
        public EditPistonDialog(int data, Action <int> handler)
        {
            XElement node = ContentManager.Get <XElement>("Dialogs/EditPistonDialog");

            LoadContents(this, node);
            m_title               = Children.Find <LabelWidget>("EditPistonDialog.Title");
            m_slider1             = Children.Find <SliderWidget>("EditPistonDialog.Slider1");
            m_panel2              = Children.Find <ContainerWidget>("EditPistonDialog.Panel2");
            m_slider2             = Children.Find <SliderWidget>("EditPistonDialog.Slider2");
            m_slider3             = Children.Find <SliderWidget>("EditPistonDialog.Slider3");
            m_okButton            = Children.Find <ButtonWidget>("EditPistonDialog.OK");
            m_cancelButton        = Children.Find <ButtonWidget>("EditPistonDialog.Cancel");
            m_handler             = handler;
            m_data                = data;
            m_mode                = PistonBlock.GetMode(data);
            m_maxExtension        = PistonBlock.GetMaxExtension(data);
            m_pullCount           = PistonBlock.GetPullCount(data);
            m_speed               = PistonBlock.GetSpeed(data);
            m_title.Text          = "Edit " + BlocksManager.Blocks[237].GetDisplayName(null, Terrain.MakeBlockValue(237, 0, data));
            m_slider1.Granularity = 1f;
            m_slider1.MinValue    = 1f;
            m_slider1.MaxValue    = 8f;
            m_slider2.Granularity = 1f;
            m_slider2.MinValue    = 1f;
            m_slider2.MaxValue    = 8f;
            m_slider3.Granularity = 1f;
            m_slider3.MinValue    = 0f;
            m_slider3.MaxValue    = 3f;
            m_panel2.IsVisible    = (m_mode != PistonMode.Pushing);
            UpdateControls();
        }
예제 #4
0
        public override void OnBlockRemoved(int value, int newValue, int x, int y, int z)
        {
            int num  = Terrain.ExtractContents(value);
            int data = Terrain.ExtractData(value);

            switch (num)
            {
            case 237:
            {
                StopPiston(new Point3(x, y, z));
                int    face2      = PistonBlock.GetFace(data);
                Point3 point2     = CellFace.FaceToPoint3(face2);
                int    cellValue3 = m_subsystemTerrain.Terrain.GetCellValue(x + point2.X, y + point2.Y, z + point2.Z);
                int    num4       = Terrain.ExtractContents(cellValue3);
                int    data4      = Terrain.ExtractData(cellValue3);
                if (num4 == 238 && PistonHeadBlock.GetFace(data4) == face2)
                {
                    m_subsystemTerrain.DestroyCell(0, x + point2.X, y + point2.Y, z + point2.Z, 0, noDrop: false, noParticleSystem: false);
                }
                break;
            }

            case 238:
                if (!m_allowPistonHeadRemove)
                {
                    int    face       = PistonHeadBlock.GetFace(data);
                    Point3 point      = CellFace.FaceToPoint3(face);
                    int    cellValue  = m_subsystemTerrain.Terrain.GetCellValue(x + point.X, y + point.Y, z + point.Z);
                    int    cellValue2 = m_subsystemTerrain.Terrain.GetCellValue(x - point.X, y - point.Y, z - point.Z);
                    int    num2       = Terrain.ExtractContents(cellValue);
                    int    num3       = Terrain.ExtractContents(cellValue2);
                    int    data2      = Terrain.ExtractData(cellValue);
                    int    data3      = Terrain.ExtractData(cellValue2);
                    if (num2 == 238 && PistonHeadBlock.GetFace(data2) == face)
                    {
                        m_subsystemTerrain.DestroyCell(0, x + point.X, y + point.Y, z + point.Z, 0, noDrop: false, noParticleSystem: false);
                    }
                    if (num3 == 237 && PistonBlock.GetFace(data3) == face)
                    {
                        m_subsystemTerrain.DestroyCell(0, x - point.X, y - point.Y, z - point.Z, 0, noDrop: false, noParticleSystem: false);
                    }
                    else if (num3 == 238 && PistonHeadBlock.GetFace(data3) == face)
                    {
                        m_subsystemTerrain.DestroyCell(0, x - point.X, y - point.Y, z - point.Z, 0, noDrop: false, noParticleSystem: false);
                    }
                }
                break;
            }
        }
예제 #5
0
 public void UpdateMovableBlocks()
 {
     foreach (IMovingBlockSet movingBlockSet in m_subsystemMovingBlocks.MovingBlockSets)
     {
         if (movingBlockSet.Id == "Piston")
         {
             Point3 point     = (Point3)movingBlockSet.Tag;
             int    cellValue = m_subsystemTerrain.Terrain.GetCellValue(point.X, point.Y, point.Z);
             if (Terrain.ExtractContents(cellValue) == 237)
             {
                 int        data = Terrain.ExtractData(cellValue);
                 PistonMode mode = PistonBlock.GetMode(data);
                 int        face = PistonBlock.GetFace(data);
                 Point3     p    = CellFace.FaceToPoint3(face);
                 int        num  = int.MaxValue;
                 foreach (MovingBlock block in movingBlockSet.Blocks)
                 {
                     num = MathUtils.Min(num, block.Offset.X * p.X + block.Offset.Y * p.Y + block.Offset.Z * p.Z);
                 }
                 float num2 = movingBlockSet.Position.X * (float)p.X + movingBlockSet.Position.Y * (float)p.Y + movingBlockSet.Position.Z * (float)p.Z;
                 float num3 = point.X * p.X + point.Y * p.Y + point.Z * p.Z;
                 if (num2 > num3)
                 {
                     if ((float)num + num2 - num3 > 1f)
                     {
                         movingBlockSet.SetBlock(p * (num - 1), Terrain.MakeBlockValue(238, 0, PistonHeadBlock.SetFace(PistonHeadBlock.SetIsShaft(PistonHeadBlock.SetMode(0, mode), isShaft: true), face)));
                     }
                 }
                 else if (num2 < num3 && (float)num + num2 - num3 <= 0f)
                 {
                     movingBlockSet.SetBlock(p * num, 0);
                 }
             }
         }
     }
 }
예제 #6
0
        public static bool IsBlockMovable(int value, int pistonFace, int y, out bool isEnd)
        {
            isEnd = false;
            int num  = Terrain.ExtractContents(value);
            int data = Terrain.ExtractData(value);

            switch (num)
            {
            case 27:
            case 45:
            case 64:
            case 65:
            case 216:
                return(false);

            case 227:
                return(true);

            case 237:
                return(!PistonBlock.GetIsExtended(data));

            case 238:
                return(false);

            case 131:
            case 132:
            case 244:
                return(false);

            case 127:
                return(false);

            case 126:
                return(false);

            case 1:
                return(y > 1);

            default:
            {
                Block block = BlocksManager.Blocks[num];
                if (block is BottomSuckerBlock)
                {
                    return(false);
                }
                if (block is MountedElectricElementBlock)
                {
                    isEnd = true;
                    return(((MountedElectricElementBlock)block).GetFace(value) == pistonFace);
                }
                if (block is DoorBlock || block is TrapdoorBlock)
                {
                    return(false);
                }
                if (block is LadderBlock)
                {
                    isEnd = true;
                    return(pistonFace == LadderBlock.GetFace(data));
                }
                if (block is AttachedSignBlock)
                {
                    isEnd = true;
                    return(pistonFace == AttachedSignBlock.GetFace(data));
                }
                if (block.IsNonDuplicable)
                {
                    return(false);
                }
                if (block.IsCollidable)
                {
                    return(true);
                }
                return(false);
            }
            }
        }
예제 #7
0
        public void StopPiston(Point3 position)
        {
            IMovingBlockSet movingBlockSet = m_subsystemMovingBlocks.FindMovingBlocks("Piston", position);

            if (movingBlockSet != null)
            {
                int  cellValue  = m_subsystemTerrain.Terrain.GetCellValue(position.X, position.Y, position.Z);
                int  num        = Terrain.ExtractContents(cellValue);
                int  data       = Terrain.ExtractData(cellValue);
                bool flag       = num == 237;
                bool isExtended = false;
                m_subsystemMovingBlocks.RemoveMovingBlockSet(movingBlockSet);
                foreach (MovingBlock block in movingBlockSet.Blocks)
                {
                    int x = Terrain.ToCell(MathUtils.Round(movingBlockSet.Position.X)) + block.Offset.X;
                    int y = Terrain.ToCell(MathUtils.Round(movingBlockSet.Position.Y)) + block.Offset.Y;
                    int z = Terrain.ToCell(MathUtils.Round(movingBlockSet.Position.Z)) + block.Offset.Z;
                    if (!(new Point3(x, y, z) == position))
                    {
                        int num2 = Terrain.ExtractContents(block.Value);
                        if (flag || num2 != 238)
                        {
                            m_subsystemTerrain.DestroyCell(0, x, y, z, block.Value, noDrop: false, noParticleSystem: false);
                            if (num2 == 238)
                            {
                                isExtended = true;
                            }
                        }
                    }
                }
                if (flag)
                {
                    m_subsystemTerrain.ChangeCell(position.X, position.Y, position.Z, Terrain.MakeBlockValue(237, 0, PistonBlock.SetIsExtended(data, isExtended)));
                }
            }
        }
예제 #8
0
        public bool MovePiston(Point3 position, int length)
        {
            Terrain    terrain      = m_subsystemTerrain.Terrain;
            int        data         = Terrain.ExtractData(terrain.GetCellValue(position.X, position.Y, position.Z));
            int        face         = PistonBlock.GetFace(data);
            PistonMode mode         = PistonBlock.GetMode(data);
            int        maxExtension = PistonBlock.GetMaxExtension(data);
            int        pullCount    = PistonBlock.GetPullCount(data);
            int        speed        = PistonBlock.GetSpeed(data);
            Point3     point        = CellFace.FaceToPoint3(face);

            length = MathUtils.Clamp(length, 0, maxExtension + 1);
            int num = 0;

            m_movingBlocks.Clear();
            Point3      offset = point;
            MovingBlock item;

            while (m_movingBlocks.Count < 8)
            {
                int cellValue = terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z);
                int num2      = Terrain.ExtractContents(cellValue);
                int face2     = PistonHeadBlock.GetFace(Terrain.ExtractData(cellValue));
                if (num2 != 238 || face2 != face)
                {
                    break;
                }
                DynamicArray <MovingBlock> movingBlocks = m_movingBlocks;
                item = new MovingBlock
                {
                    Offset = offset,
                    Value  = cellValue
                };
                movingBlocks.Add(item);
                offset += point;
                num++;
            }
            if (length > num)
            {
                DynamicArray <MovingBlock> movingBlocks2 = m_movingBlocks;
                item = new MovingBlock
                {
                    Offset = Point3.Zero,
                    Value  = Terrain.MakeBlockValue(238, 0, PistonHeadBlock.SetFace(PistonHeadBlock.SetMode(PistonHeadBlock.SetIsShaft(0, num > 0), mode), face))
                };
                movingBlocks2.Add(item);
                int num3 = 0;
                while (num3 < 8)
                {
                    int cellValue2 = terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z);
                    if (!IsBlockMovable(cellValue2, face, position.Y + offset.Y, out bool isEnd))
                    {
                        break;
                    }
                    DynamicArray <MovingBlock> movingBlocks3 = m_movingBlocks;
                    item = new MovingBlock
                    {
                        Offset = offset,
                        Value  = cellValue2
                    };
                    movingBlocks3.Add(item);
                    num3++;
                    offset += point;
                    if (isEnd)
                    {
                        break;
                    }
                }
                if (!IsBlockBlocking(terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z)))
                {
                    GetSpeedAndSmoothness(speed, out float speed2, out Vector2 smoothness);
                    Point3 p = position + (length - num) * point;
                    if (m_subsystemMovingBlocks.AddMovingBlockSet(new Vector3(position) + 0.01f * new Vector3(point), new Vector3(p), speed2, 0f, 0f, smoothness, m_movingBlocks, "Piston", position, testCollision: true) != null)
                    {
                        m_allowPistonHeadRemove = true;
                        try
                        {
                            foreach (MovingBlock movingBlock in m_movingBlocks)
                            {
                                if (movingBlock.Offset != Point3.Zero)
                                {
                                    m_subsystemTerrain.ChangeCell(position.X + movingBlock.Offset.X, position.Y + movingBlock.Offset.Y, position.Z + movingBlock.Offset.Z, 0);
                                }
                            }
                        }
                        finally
                        {
                            m_allowPistonHeadRemove = false;
                        }
                        m_subsystemTerrain.ChangeCell(position.X, position.Y, position.Z, Terrain.MakeBlockValue(237, 0, PistonBlock.SetIsExtended(data, isExtended: true)));
                        m_subsystemAudio.PlaySound("Audio/Piston", 1f, 0f, new Vector3(position), 2f, autoDelay: true);
                    }
                }
                return(false);
            }
            if (length < num)
            {
                if (mode != 0)
                {
                    int num4 = 0;
                    for (int i = 0; i < pullCount + 1; i++)
                    {
                        int cellValue3 = terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z);
                        if (!IsBlockMovable(cellValue3, face, position.Y + offset.Y, out bool isEnd2))
                        {
                            break;
                        }
                        DynamicArray <MovingBlock> movingBlocks4 = m_movingBlocks;
                        item = new MovingBlock
                        {
                            Offset = offset,
                            Value  = cellValue3
                        };
                        movingBlocks4.Add(item);
                        offset += point;
                        num4++;
                        if (isEnd2)
                        {
                            break;
                        }
                    }
                    if (mode == PistonMode.StrictPulling && num4 < pullCount + 1)
                    {
                        return(false);
                    }
                }
                GetSpeedAndSmoothness(speed, out float speed3, out Vector2 smoothness2);
                float   s = (length == 0) ? 0.01f : 0f;
                Vector3 targetPosition = new Vector3(position) + (length - num) * new Vector3(point) + s * new Vector3(point);
                if (m_subsystemMovingBlocks.AddMovingBlockSet(new Vector3(position), targetPosition, speed3, 0f, 0f, smoothness2, m_movingBlocks, "Piston", position, testCollision: true) != null)
                {
                    m_allowPistonHeadRemove = true;
                    try
                    {
                        foreach (MovingBlock movingBlock2 in m_movingBlocks)
                        {
                            m_subsystemTerrain.ChangeCell(position.X + movingBlock2.Offset.X, position.Y + movingBlock2.Offset.Y, position.Z + movingBlock2.Offset.Z, 0);
                        }
                    }
                    finally
                    {
                        m_allowPistonHeadRemove = false;
                    }
                    m_subsystemAudio.PlaySound("Audio/Piston", 1f, 0f, new Vector3(position), 2f, autoDelay: true);
                }
                return(false);
            }
            return(true);
        }