Beispiel #1
0
        public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
        {
            int blockid = Terrain.ExtractContents(raycastResult.Value);
            int id      = ILibrary.getItemId(raycastResult.Value);

            switch (blockid)
            {
            case 1006:
                switch (id)
                {
                case 500:
                    componentMiner.ComponentPlayer.ComponentGui.DisplaySmallMessage("", false, false);
                    break;
                }

                break;

            case 1007:
                switch (id)
                {
                case 39:
                    subsystemItemElectricBehavior.OnInteract(raycastResult, componentMiner);
                    break;

                case 102: break;
                }
                break;
            }
            return(false);
        }
        public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
        {
            component = componentMiner.ComponentPlayer;
            int id = Terrain.ExtractContents(componentMiner.ActiveBlockValue);
            TerrainRaycastResult?raycastResult = componentMiner.PickTerrainForDigging(start, direction);
            int data = Terrain.ExtractData(componentMiner.ActiveBlockValue);

            switch (data)
            {
            case 0:
                componentMiner.ComponentPlayer.ComponentGui.DisplaySmallMessage("a", false, false);
                if (raycastResult.HasValue)       //桶的使用
                {
                    Point3 point = raycastResult.Value.CellFace.Point;
                    SubsystemTerrain.Terrain.SetCellValueFast(point.X, point.Y + 2, point.Z, Terrain.MakeBlockValue(1009, 0, 0));
                }
                break;

            case 1:
                if (raycastResult.HasValue)
                {
                    Point3 point = raycastResult.Value.CellFace.Point;
                    SubsystemTerrain.Terrain.SetCellValueFast(point.X, point.Y + 2, point.Z, Terrain.MakeBlockValue(1009, 0, 1));
                }
                break;

            default:

                break;
            }
            return(false);
        }
Beispiel #3
0
 public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
 {
     ++ll; if (ll >= 2)
     {
         ll = 0; return(false);
     }
     componentPlayer = componentMiner.ComponentPlayer;
     return(false);
 }
Beispiel #4
0
 public override void Load(ValuesDictionary valuesDictionary, IdToEntityMap idToEntityMap)
 {
     componentMiner        = Entity.FindComponent <ComponentMiner>();
     subsystemTerrain      = Entity.Project.FindSubsystem <SubsystemTerrain>();
     subsystemMovingBlocks = Entity.Project.FindSubsystem <SubsystemMovingBlocks>();
     electricBlockBehavior = Entity.Project.FindSubsystem <SubsystemItemElectricBehavior>();
     terrain = subsystemTerrain.Terrain;
     Data    = new Dictionary <Point3, TerrainGeometrySubsets>();
     shader  = ContentManager.Get <Shader>("Shaders/Transparent");
 }
Beispiel #5
0
 public CreatorAPI(ComponentMiner componentMiner)
 {
     creatorGenerationAlgorithm = new CreatorGenerationAlgorithm();
     this.componentMiner        = componentMiner;
     this.Position = new List <Point3>(4)
     {
         new Point3(0, -1, 0),
         new Point3(0, -1, 0),
         new Point3(0, -1, 0),
         new Point3(0, -1, 0)
     };
 }
Beispiel #6
0
 public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
 {
     if (Utils.SubsystemGameInfo.WorldSettings.GameMode != GameMode.Adventure)
     {
         var blockEntity = Utils.GetBlockEntity(raycastResult.CellFace.Point);
         if (blockEntity != null && componentMiner.ComponentPlayer != null)
         {
             ComponentLiquidPump componentDispenser = blockEntity.Entity.FindComponent <ComponentLiquidPump>(true);
             componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new LiquidPumpWidget(componentMiner.Inventory, componentDispenser);
             AudioManager.PlaySound("Audio/UI/ButtonClick", 1f, 0f, 0f);
             return(true);
         }
     }
     return(false);
 }
Beispiel #7
0
        public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
        {        //记录point
            ++ll; if (ll >= 2)
            {
                ll = 0; return(true);
            }
            componentPlayer = componentMiner.ComponentPlayer;
            ComponentBlockEntity componentBlockEntity = subsystemBlockEntities.GetBlockEntity(raycastResult.CellFace.X, raycastResult.CellFace.Y, raycastResult.CellFace.Z);

            if (componentBlockEntity == null)
            {
                toast("没有找到Blockentity"); return(false);
            }
            ComponentSingleChest singleChestData = componentBlockEntity.Entity.FindComponent <ComponentSingleChest>(true);

            singleChestData.Droptems(new Vector3(raycastResult.CellFace.X, raycastResult.CellFace.Y, raycastResult.CellFace.Z) + new Vector3(1f, 1f, 1f), 1);
            return(true);
        }
        public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
        {
            TerrainRaycastResult?terrainRaycastResult = componentMiner.PickTerrainForDigging(start, direction);
            ComponentPlayer      Player = componentMiner.ComponentPlayer;

            if (terrainRaycastResult.HasValue)
            {
                CreatorAPI creatorAPI;
                if (!dictionaryPlayers.TryGetValue(Player, out creatorAPI))
                {
                    listPlayer.Add(Player);
                    creatorAPI = new CreatorAPI(componentMiner);
                    dictionaryPlayers.Add(Player, creatorAPI);
                }
                creatorAPI.OnUse((TerrainRaycastResult)terrainRaycastResult);
            }
            return(base.OnUse(start, direction, componentMiner));
        }
Beispiel #9
0
        public static BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
        {
            BlockPlacementData result = default(BlockPlacementData);
            int     realdata          = 0;//位置修正
            Vector3 forward           = Matrix.CreateFromQuaternion(componentMiner.ComponentCreature.ComponentCreatureModel.EyeRotation).Forward;
            float   num  = Vector3.Dot(forward, Vector3.UnitZ);
            float   num2 = Vector3.Dot(forward, Vector3.UnitX);
            float   num3 = Vector3.Dot(forward, -Vector3.UnitZ);
            float   num4 = Vector3.Dot(forward, -Vector3.UnitX);

            if (num == MathUtils.Max(num, num2, num3, num4))
            {
                realdata = 2;
            }
            else if (num2 == MathUtils.Max(num, num2, num3, num4))
            {
                realdata = 3;
            }
            else if (num3 == MathUtils.Max(num, num2, num3, num4))
            {
                realdata = 0;
            }
            else if (num4 == MathUtils.Max(num, num2, num3, num4))
            {
                realdata = 1;
            }
            result.Value    = ILibrary.setDirection(value, realdata);//4*4表示方块位置,朝向
            result.CellFace = raycastResult.CellFace;
            return(result);
        }
Beispiel #10
0
 public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
 {
     return(ILibrary.GetPlacementValue(subsystemTerrain, componentMiner, value, raycastResult));
 }
Beispiel #11
0
        public virtual BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
        {
            BlockPlacementData result = default;

            result.Value    = value;
            result.CellFace = raycastResult.CellFace;
            return(result);
        }
Beispiel #12
0
        public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
        {
            int value2 = value;

            return(GetItem(ref value2).GetPlacementValue(subsystemTerrain, componentMiner, value, raycastResult));
        }
Beispiel #13
0
 public override BlockPlacementData GetDigValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, int toolValue, TerrainRaycastResult raycastResult)
 {
     return(GetItem(ref value).GetDigValue(subsystemTerrain, componentMiner, value, toolValue, raycastResult));
 }
Beispiel #14
0
 public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
 {
     return(new BlockPlacementData {
         Value = value, CellFace = raycastResult.CellFace
     });
 }
 public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
 {
     componentPlayer = componentMiner.ComponentPlayer;
     return(base.OnUse(start, direction, componentMiner));
 }
 public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
 {
     subsystemCreatureSpawn.SpawnCreature("Duck", start + new Vector3(1, 1, 1), true);
     return(false);
 }
Beispiel #17
0
        public override bool OnUse(Vector3 start, Vector3 direction, ComponentMiner componentMiner)
        {
            int blockid = Terrain.ExtractContents(componentMiner.ActiveBlockValue);
            int id      = ILibrary.getItemId(componentMiner.ActiveBlockValue);

            switch (blockid)
            {
            case 1006:
                switch (id)
                {
                case 500:
                    TerrainRaycastResult?raycastResult = componentMiner.PickTerrainForDigging(start, direction);
                    if (TransmitSetflag && !raycastResult.HasValue)          //设定了传送地点且不对准传送机
                    {
                        subsystemItemElectricBehavior.tranFLag = true;
                        subsystemItemElectricBehavior.leftFLag = false;
                        componentMiner.ComponentPlayer.ComponentBody.Position = new Vector3(TransmitStartPoint.X, TransmitStartPoint.Y + 1, TransmitStartPoint.Z + 1);
                        SubsystemTerrain.TerrainUpdater.UpdateChunkSingleStep(SubsystemTerrain.Terrain.GetChunkAtCell(TransmitStartPoint.X, TransmitStartPoint.Z), 15);
                    }
                    if (Terrain.ExtractContents(raycastResult.Value.Value) == 1003 && Terrain.ExtractData(raycastResult.Value.Value) == 64)
                    {
                        if (!TransmitSetflag)           //没有设定地点
                        {
                            TransmitStartPoint = raycastResult.Value.CellFace.Point;
                            TransmitSetflag    = true;
                            componentMiner.ComponentPlayer.ComponentGui.DisplaySmallMessage("传送门1设定成功", false, false);
                            return(false);
                        }
                        if (raycastResult.Value.CellFace.Point != TransmitStartPoint && TransmitSetflag)
                        {
                            if (subsystemItemElectricBehavior.tranmitPoints.TryGetValue(TransmitStartPoint, out NewMutiBlockCheck.TranmitResult tranmitResult))
                            {
                                NewMutiBlockCheck.TranmitResult tranmitResult1 = subsystemItemElectricBehavior.tranmitPoints[TransmitStartPoint];
                                if (subsystemItemElectricBehavior.tranmitPoints.TryGetValue(raycastResult.Value.CellFace.Point, out NewMutiBlockCheck.TranmitResult tranmitResultaa))
                                {
                                    NewMutiBlockCheck.TranmitResult tranmitResult2 = subsystemItemElectricBehavior.tranmitPoints[raycastResult.Value.CellFace.Point];
                                    TransmitSetflag             = false;
                                    tranmitResult2.connectPoint = TransmitStartPoint;
                                    tranmitResult1.connectPoint = raycastResult.Value.CellFace.Point;
                                    subsystemItemElectricBehavior.tranmitPoints[TransmitStartPoint] = tranmitResult1;
                                    subsystemItemElectricBehavior.tranmitPoints[raycastResult.Value.CellFace.Point] = tranmitResult2;
                                    componentMiner.ComponentPlayer.ComponentGui.DisplaySmallMessage("传送门连接成功", false, false);
                                    return(false);
                                }
                                else
                                {
                                    componentMiner.ComponentPlayer.ComponentGui.DisplaySmallMessage("传送门结构被破坏,无法连接", false, false);
                                    return(false);
                                }
                            }
                        }
                    }
                    break;
                }

                break;

            case 1007:

                switch (id)
                {
                case 39:
                    break;
                }
                break;
            }
            return(false);
        }
        internal static void WorldEditModApi()
        {
            if (!(ScreensManager.GetScreenName(ScreensManager.CurrentScreen) == "Game")) // Выходим, если мы не в игре
            {
                return;
            }

            // Показазывеем контейнер с кнопками, если активирована кнопка WorldEditMenu
            ScreensManager.CurrentScreen.ScreenWidget.FindWidget <StackPanelWidget>("WorldEditMenuContainerTop", true).IsVisible    = ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("WorldEditMenu", true).IsChecked;
            ScreensManager.CurrentScreen.ScreenWidget.FindWidget <StackPanelWidget>("WorldEditMenuContainerBottom", true).IsVisible = ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("WorldEditMenu", true).IsChecked;

            // Смена режима управления
            if (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("WorldEditMenu", true).IsTapped)
            {
                if (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("WorldEditMenu", true).IsChecked)
                {
                    OldLookControlMode = (int)SettingsManager.LookControlMode;
                    SettingsManager.LookControlMode = LookControlMode.SplitTouch;
                }
                else
                {
                    SettingsManager.LookControlMode = (LookControlMode)OldLookControlMode;
                }
            }

            if ((Engine.Input.Keyboard.IsKeyDown(Engine.Input.Key.F1)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F1", true).IsTapped)) // Выделение 1 точки
            {
                ComponentMiner componentMiner = Subsystems.Player.ComponentPlayer.ComponentMiner;
                Point1 = componentMiner.PickTerrainForDigging(Subsystems.Drawing.ViewPosition, Subsystems.Drawing.ViewDirection);

                if (Point1.HasValue)
                {
                    SCModApi.Gui.DisplayMessage("Set position 1 on: " + Point1.Value.CellFace.X + ", " + Point1.Value.CellFace.Y + ", " + Point1.Value.CellFace.Z, false);
                    SelectedBlock = World.GetBlock(Point1.Value.CellFace.X, Point1.Value.CellFace.Y, Point1.Value.CellFace.Z);
                    return;
                }
            }

            if ((Engine.Input.Keyboard.IsKeyDown(Engine.Input.Key.F2)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F2", true).IsTapped)) // Выделение 2 точки
            {
                ComponentMiner componentMiner = Subsystems.Player.ComponentPlayer.ComponentMiner;
                Point2 = componentMiner.PickTerrainForDigging(Subsystems.Drawing.ViewPosition, Subsystems.Drawing.ViewDirection);
                if (Point2.HasValue)
                {
                    SCModApi.Gui.DisplayMessage("Set position 2 on: " + Point1.Value.CellFace.X + ", " + Point1.Value.CellFace.Y + ", " + Point1.Value.CellFace.Z, false);
                    ReplaceableBlock = Subsystems.Terrain.TerrainData.GetCellValue(Point2.Value.CellFace.X, Point2.Value.CellFace.Y, Point2.Value.CellFace.Z);
                    return;
                }
            }

            if ((Engine.Input.Keyboard.IsKeyDown(Engine.Input.Key.F3)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F3", true).IsTapped)) // Выделение 3 точки
            {
                ComponentMiner componentMiner = Subsystems.Player.ComponentPlayer.ComponentMiner;
                Point3 = componentMiner.PickTerrainForDigging(Subsystems.Drawing.ViewPosition, Subsystems.Drawing.ViewDirection);
                if (Point3.HasValue)
                {
                    SCModApi.Gui.DisplayMessage("Set position 3 on: " + Point1.Value.CellFace.X + ", " + Point1.Value.CellFace.Y + ", " + Point1.Value.CellFace.Z, false);
                    return;
                }
            }

            if (Point1.HasValue && Point2.HasValue && ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("WorldEditMenu", true).IsChecked) // Выделение зоны между точками 1 и 2
            {
                int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                int endX   = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                int endY   = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
                int endZ   = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);

                PrimitivesRenderer3D PrimitivesRenderer3D = new PrimitivesRenderer3D();
                Vector3     pointStart  = new Vector3(startX, startY, startZ);
                Vector3     pointEnd    = new Vector3(endX + 1, endY + 1, endZ + 1);
                BoundingBox boundingBox = new BoundingBox(pointStart, pointEnd);
                PrimitivesRenderer3D.FlatBatch(-1, DepthStencilState.None, (RasterizerState)null, (BlendState)null).QueueBoundingBox(boundingBox, Color.Green);
                PrimitivesRenderer3D.Flush(Subsystems.Drawing.ViewProjectionMatrix, true);
            }

            if (Point3.HasValue && ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("WorldEditMenu", true).IsChecked) // Выделение зоны вставки
            {
                int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                int endX   = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                int endY   = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
                int endZ   = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);

                startX += Point3.Value.CellFace.Point.X - Point1.Value.CellFace.Point.X;
                startY += Point3.Value.CellFace.Point.Y - Point1.Value.CellFace.Point.Y;
                startZ += Point3.Value.CellFace.Point.Z - Point1.Value.CellFace.Point.Z;
                endX   += Point3.Value.CellFace.Point.X - Point1.Value.CellFace.Point.X;
                endY   += Point3.Value.CellFace.Point.Y - Point1.Value.CellFace.Point.Y;
                endZ   += Point3.Value.CellFace.Point.Z - Point1.Value.CellFace.Point.Z;

                PrimitivesRenderer3D primitivesRenderer3D = new PrimitivesRenderer3D();
                Vector3     pointStart  = new Vector3(startX, startY, startZ);
                Vector3     pointEnd    = new Vector3(endX + 1, endY + 1, endZ + 1);
                BoundingBox boundingBox = new BoundingBox(pointStart, pointEnd);
                primitivesRenderer3D.FlatBatch(-1, DepthStencilState.None, (RasterizerState)null, (BlendState)null).QueueBoundingBox(boundingBox, Color.Red);
                primitivesRenderer3D.Flush(Subsystems.Drawing.ViewProjectionMatrix, true);
            }

            if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F5)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F5", true).IsTapped)) // Копирование выделенной зоны
            {
                if (Point1 == null)
                {
                    Gui.DisplayMessage("You have not selected point 1", false);
                }
                else if (Point2 == null)
                {
                    Gui.DisplayMessage("You have not selected point 2", false);
                }
                else if (Point3 == null)
                {
                    Gui.DisplayMessage("You have not selected point 3", false);
                }
                else
                {
                    int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int endX   = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int endY   = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
                    int endZ   = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);

                    for (int y = 0; y <= endY - startY; y++)
                    {
                        for (int z = 0; z <= endZ - startZ; z++)
                        {
                            for (int x = 0; x <= endX - startX; x++)
                            {
                                int targetX, targetY, targetZ;
                                int PlaceX, PlaceY, PlaceZ;
                                if (Point1.Value.CellFace.Point.X > Point2.Value.CellFace.Point.X)
                                {
                                    targetX = Point1.Value.CellFace.Point.X - x;
                                    PlaceX  = Point3.Value.CellFace.Point.X - x;
                                }
                                else
                                {
                                    targetX = Point1.Value.CellFace.Point.X + x;
                                    PlaceX  = Point3.Value.CellFace.Point.X + x;
                                }

                                if (Point1.Value.CellFace.Point.Y > Point2.Value.CellFace.Point.Y)
                                {
                                    targetY = Point1.Value.CellFace.Point.Y - y;
                                    PlaceY  = Point3.Value.CellFace.Point.Y - y;
                                }
                                else
                                {
                                    targetY = Point1.Value.CellFace.Point.Y + y;
                                    PlaceY  = Point3.Value.CellFace.Point.Y + y;
                                }

                                if (Point1.Value.CellFace.Point.Z > Point2.Value.CellFace.Point.Z)
                                {
                                    targetZ = Point1.Value.CellFace.Point.Z - z;
                                    PlaceZ  = Point3.Value.CellFace.Point.Z - z;
                                }
                                else
                                {
                                    targetZ = Point1.Value.CellFace.Point.Z + z;
                                    PlaceZ  = Point3.Value.CellFace.Point.Z + z;
                                }

                                int block = World.GetBlock(targetX, targetY, targetZ);
                                // 15360 - Air
                                if (block != 15360)
                                {
                                    World.SetBlock(PlaceX, PlaceY, PlaceZ, block);
                                }
                            }
                        }
                    }
                }
                return;
            }

            if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F6)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F6", true).IsTapped)) // Заполнение зоны
            {
                if (Point1 == null)
                {
                    Gui.DisplayMessage("You have not selected point 1", false);
                }
                else if (Point2 == null)
                {
                    Gui.DisplayMessage("You have not selected point 2", false);
                }
                else
                {
                    int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int endX   = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int endY   = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
                    int endZ   = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);

                    for (int x = startX; x <= endX; x++)
                    {
                        for (int y = startY; y <= endY; y++)
                        {
                            for (int z = startZ; z <= endZ; z++)
                            {
                                World.SetBlock(x, y, z, SelectedBlock);
                            }
                        }
                    }
                }
                return;
            }

            if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F7)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F7", true).IsTapped)) // Замена зоны
            {
                if (Point1 == null)
                {
                    Gui.DisplayMessage("You have not selected point 1", false);
                }
                else if (Point2 == null)
                {
                    Gui.DisplayMessage("You have not selected point 2", false);
                }
                else
                {
                    int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int endX   = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int endY   = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
                    int endZ   = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);


                    for (int x = startX; x <= endX; x++)
                    {
                        for (int y = startY; y <= endY; y++)
                        {
                            for (int z = startZ; z <= endZ; z++)
                            {
                                if (World.GetBlock(x, y, z) == ReplaceableBlock)
                                {
                                    World.SetBlock(x, y, z, SelectedBlock);
                                }
                            }
                        }
                    }
                }
                return;
            }

            if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F8)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F8", true).IsTapped)) // Очистка зоны
            {
                if (Point1 == null)
                {
                    Gui.DisplayMessage("You have not selected point 1", false);
                }
                else if (Point2 == null)
                {
                    Gui.DisplayMessage("You have not selected point 2", false);
                }
                else
                {
                    int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int endX   = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int endY   = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
                    int endZ   = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);

                    for (int x = startX; x <= endX; x++)
                    {
                        for (int y = startY; y <= endY; y++)
                        {
                            for (int z = startZ; z <= endZ; z++)
                            {
                                World.SetBlock(x, y, z, 0);
                            }
                        }
                    }
                }
                return;
            }

            if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F9)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F9", true).IsTapped)) // Копирование зоны в память
            {
                if (Point1 == null)
                {
                    Gui.DisplayMessage("You have not selected point 1", false);
                }
                else if (Point2 == null)
                {
                    Gui.DisplayMessage("You have not selected point 2", false);
                }
                else
                {
                    int startX = Math.Min(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int endX   = Math.Max(Point1.Value.CellFace.Point.X, Point2.Value.CellFace.Point.X);
                    int startY = Math.Min(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int endY   = Math.Max(Point1.Value.CellFace.Point.Y, Point2.Value.CellFace.Point.Y);
                    int startZ = Math.Min(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);
                    int endZ   = Math.Max(Point1.Value.CellFace.Point.Z, Point2.Value.CellFace.Point.Z);

                    blockCount = 0;
                    BlockList.Clear();

                    for (int x = 0; x <= endX - startX; x++)
                    {
                        for (int y = 0; y <= endY - startY; y++)
                        {
                            for (int z = 0; z <= endZ - startZ; z++)
                            {
                                BlockMem blmem = new BlockMem();
                                int      X, Y, Z;
                                if (Point1.Value.CellFace.Point.X > Point2.Value.CellFace.Point.X)
                                {
                                    blmem.x = -x;
                                    X       = Point1.Value.CellFace.Point.X - x;
                                }
                                else
                                {
                                    blmem.x = x;
                                    X       = Point1.Value.CellFace.Point.X + x;
                                }

                                if (Point1.Value.CellFace.Point.Y > Point2.Value.CellFace.Point.Y)
                                {
                                    blmem.y = -y;
                                    Y       = Point1.Value.CellFace.Point.Y - y;
                                }
                                else
                                {
                                    blmem.y = y;
                                    Y       = Point1.Value.CellFace.Point.Y + y;
                                }

                                if (Point1.Value.CellFace.Point.Z > Point2.Value.CellFace.Point.Z)
                                {
                                    blmem.z = -z;
                                    Z       = Point1.Value.CellFace.Point.Z - z;
                                }
                                else
                                {
                                    blmem.z = z;
                                    Z       = Point1.Value.CellFace.Point.Z + z;
                                }

                                blmem.id = World.GetBlock(X, Y, Z);
                                BlockList.Add(blmem);
                                blockCount++;
                            }
                        }
                    }
                }
                Gui.DisplayMessage("Copied " + blockCount + " blocks", false);
                return;
            }

            if ((Engine.Input.Keyboard.IsKeyDownOnce(Engine.Input.Key.F10)) || (ScreensManager.CurrentScreen.ScreenWidget.FindWidget <BitmapButtonWidget>("F10", true).IsTapped))  // Вставка зоны из памяти
            {
                if (Point3 == null)
                {
                    Gui.DisplayMessage("You have not selected point 3", false);
                }
                else
                {
                    for (var i = 0; i < blockCount; i++)
                    {
                        var xPos = Point3.Value.CellFace.X + BlockList[i].x;
                        var yPos = Point3.Value.CellFace.Y + BlockList[i].y;
                        var zPos = Point3.Value.CellFace.Z + BlockList[i].z;

                        World.SetBlock(xPos, yPos, zPos, BlockList[i].id);
                    }
                    Gui.DisplayMessage("Pasted " + blockCount + " blocks", false);
                }
            }
        }
Beispiel #19
0
 public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
 {
     return(Utils.SubsystemGameInfo.WorldSettings.GameMode != GameMode.Adventure && base.OnInteract(raycastResult, componentMiner));
 }
 public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
 {
     return(base.OnInteract(raycastResult, componentMiner));
 }
        public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
        {
            ComponentEnergyMachine mcomponent;
            ComponentFluidStore    componentFluidStore;
            PanelWidget            panelWidget = new PanelWidget();
            int    value = raycastResult.Value;
            Point3 point = raycastResult.CellFace.Point;
            int    ID    = ILibrary.getItemId(value);

            if (Terrain.ExtractContents(value) == 1003)
            {
                switch (ID)
                {
                case 27:
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <ComponentCoalGenerator>(true);
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new CoalGeneratorWidget((ComponentCoalGenerator)mcomponent);
                    break;

                case 30:
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <CptEgySolarGtor>(true);
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new AspSolarWidget((CptEgySolarGtor)mcomponent);
                    break;

                case 40:
                    NewMutiBlockCheck.Result result = mutiBlockCheck.checkMutiBlocks(SubsystemTerrain.Terrain, point, dynamic_outsideaccept, dynamic_insideaccept, dynamic_sideaccept, dynamic_faceaccept);
                    if (result.finish)
                    {
                        componentFluidStore = subsystemBlockEntities.GetBlockEntity(result.savaPoint.X, result.savaPoint.Y, result.savaPoint.Z).Entity.FindComponent <ComponentMekDynamic>(true);
                        componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new MekDynamicWidget((ComponentMekDynamic)componentFluidStore);
                    }
                    break;

                case 41:
                    result = mutiBlockCheck.checkMutiBlocks(SubsystemTerrain.Terrain, point, dynamic_outsideaccept, dynamic_insideaccept, dynamic_sideaccept, dynamic_faceaccept);
                    if (result.finish)
                    {
                        componentFluidStore = subsystemBlockEntities.GetBlockEntity(result.savaPoint.X, result.savaPoint.Y, result.savaPoint.Z).Entity.FindComponent <ComponentMekDynamic>(true);
                        componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new MekDynamicWidget((ComponentMekDynamic)componentFluidStore);
                    }
                    break;

                case 47:
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <ComponentCrusher>();
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new CrusherWidget((ComponentCrusher)mcomponent);
                    break;

                case 48: break;

                case 49: break;

                case 50: break;

                case 51: break;

                case 52: break;

                case 63:    //基础能量立方
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <ComponentEnergyMachine>(true);
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new EnergyCubeWidget(mcomponent);
                    break;

                case 64:
                    if (Terrain.ExtractContents(componentMiner.ActiveBlockValue) == 1006 && Terrain.ExtractData(componentMiner.ActiveBlockValue) == 500)
                    {
                        return(true);
                    }
                    if (tranmitPoints.TryGetValue(point, out NewMutiBlockCheck.TranmitResult tranmitResult))
                    {
                        componentMiner.ComponentPlayer.ComponentGui.DisplaySmallMessage("conn:" + tranmitResult.connectPoint.ToString(), false, false);
                    }
                    break;

                case 65:

                    break;

                case 72:         //充能冶炼炉
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <ComponentSmelt>(true);
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new MekSmeltWidget((ComponentSmelt)mcomponent);
                    break;

                case 78:    //富集仓
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <ComponentEnrich>(true);
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new EnrichWidget((ComponentEnrich)mcomponent);
                    break;

                case 80:    //合金炉
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <ComponentAlloy>(true);
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new AlloyWidget((ComponentAlloy)mcomponent);
                    break;

                case 82:    //制造厂
                    mcomponent = subsystemBlockEntities.GetBlockEntity(point.X, point.Y, point.Z).Entity.FindComponent <ComponentManufactory>(true);
                    componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new ManufactoryWidget((ComponentManufactory)mcomponent);
                    break;

                default:
                    panelWidget.setText(subsystemItemElectric.scanSlot(SubsystemTerrain.Terrain, point));
                    component.ComponentGui.ModalPanelWidget = panelWidget;
                    break;
                }
            }
            else if (Terrain.ExtractContents(value) == 1007)
            {
                switch (ID)
                {
                case 39:
                    NewMutiBlockCheck.Result result = mutiBlockCheck.checkMutiBlocks(SubsystemTerrain.Terrain, point, dynamic_outsideaccept, dynamic_insideaccept, dynamic_sideaccept, dynamic_faceaccept);
                    if (result.finish)
                    {
                        componentFluidStore = subsystemBlockEntities.GetBlockEntity(result.savaPoint.X, result.savaPoint.Y, result.savaPoint.Z).Entity.FindComponent <ComponentMekDynamic>(true);
                        componentMiner.ComponentPlayer.ComponentGui.ModalPanelWidget = new MekDynamicWidget((ComponentMekDynamic)componentFluidStore);
                    }
                    break;
                }
            }
            return(false);
        }
Beispiel #22
0
 public bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
 {
     return(componentMiner.Project.FindSubsystem <SubsystemSignBlockBehavior>(true).OnInteract(raycastResult, componentMiner));
 }
Beispiel #23
0
 public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
 {
     return(new BlockPlacementData
     {
         Value = GetType(value) == 0 ? 0 : Terrain.ReplaceLight(value, 0),
         CellFace = raycastResult.CellFace
     });
 }
Beispiel #24
0
        public override BlockPlacementData GetDigValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, int toolValue, TerrainRaycastResult raycastResult)
        {
            BlockPlacementData result = default(BlockPlacementData);

            result.CellFace = raycastResult.CellFace;
            return(result);
        }