Example #1
0
        private void Shift(object sender, EventArgs e)
        {
            if (!int.TryParse(_xTextBox.Text, out var sx) || !int.TryParse(_yTextBox.Text, out var sy))
            {
                return;
            }

            var segmentRequest = WeakReferenceMessenger.Default.Send <GetActiveSegmentRequestMessage>();
            var segment        = segmentRequest.Response;

            var oldTiles = _region.GetTiles((tile) => true).ToList();

            foreach (var tile in oldTiles)
            {
                _region.DeleteTile(tile.X, tile.Y);
            }

            foreach (var tile in oldTiles)
            {
                var dx = tile.X + sx;
                var dy = tile.Y + sy;

                var duplicate = new SegmentTile(dx, dy);

                foreach (var component in tile.Components)
                {
                    duplicate.AddComponent(component);
                }

                _region.SetTile(dx, dy, duplicate);
            }

            /* */
            foreach (var region in segment.Regions)
            {
                var linkedComponents = region.GetTiles((tile) => true)
                                       .SelectMany((tile) => tile.GetComponents <TeleportComponent>()
                                                   .Where((t) => t.DestinationRegion == _region.ID));

                foreach (var linked in linkedComponents)
                {
                    linked.DestinationX += sx;
                    linked.DestinationY += sy;
                }
            }
        }
Example #2
0
        public override void OnHandleInput(PresentationTarget target, IInputService inputService)
        {
            base.OnHandleInput(target, inputService);

            if (inputService.IsMouseOrTouchHandled)
            {
                return;
            }

            var services  = ServiceLocator.Current;
            var presenter = services.GetInstance <ApplicationPresenter>();
            var filter    = presenter.SelectedFilter;

            var worldScreen = target.WorldScreen;
            var zoomFactor  = worldScreen.ZoomFactor;
            var region      = target.Region;

            var(mx, my) = worldScreen.ToWorldCoordinates((int)_position.X, (int)_position.Y);
            var tile = region.GetTile(mx, my);

            if (tile != null)
            {
                var viewRectangle = worldScreen.GetViewRectangle();

                var rx = (int)Math.Floor((mx - viewRectangle.Left) * (presenter.UnitSize * zoomFactor));
                var ry = (int)Math.Floor((my - viewRectangle.Top) * (presenter.UnitSize * zoomFactor));

                var dx = _position.X - (rx - 45);
                var dy = _position.Y - (ry - 45);

                foreach (var component in tile.Components)
                {
                    if ((filter != null && !filter.IsValid(component)) || !IsValid(component))
                    {
                        continue;
                    }

                    var renderList = component.GetTerrain().ToList();

                    for (var i = renderList.Count - 1; i >= 0; i--)
                    {
                        var render = renderList[i];

                        foreach (var layer in render.Terrain)
                        {
                            var sprite = layer.Sprite;

                            if (sprite != null && sprite.HitTest((int)dx, (int)dy))
                            {
                                _tileUnderMouse      = tile;
                                _componentUnderMouse = component;
                            }
                        }
                    }
                }
            }

            if (!inputService.IsKeyboardHandled)
            {
                if (inputService.IsReleased(Keys.Escape))
                {
                    presenter.SelectTool(default(Tool));
                    inputService.IsKeyboardHandled = true;
                }
            }

            if (inputService.IsReleased(MouseButtons.Left))
            {
                if (_componentUnderMouse != null)
                {
                    OnClick();
                }

                if (_tileUnderMouse != null)
                {
                    _tileUnderMouse.UpdateTerrain();
                }

                worldScreen.InvalidateRender();

                inputService.IsMouseOrTouchHandled = true;
            }
        }
Example #3
0
        public override void OnHandleInput(PresentationTarget target, IInputService inputService)
        {
            base.OnHandleInput(target, inputService);

            if (inputService.IsMouseOrTouchHandled)
            {
                return;
            }

            var services  = ServiceLocator.Current;
            var presenter = services.GetInstance <ApplicationPresenter>();

            var graphicsScreen = target.WorldScreen;
            var region         = target.Region;
            var selection      = presenter.Selection;

            if (!inputService.IsKeyboardHandled)
            {
                _isShiftDown = inputService.IsDown(Keys.LeftShift) || inputService.IsDown(Keys.RightShift);
                _isAltDown   = inputService.IsDown(Keys.LeftAlt) || inputService.IsDown(Keys.RightAlt);

                if (inputService.IsReleased(Keys.Escape))
                {
                    presenter.SelectTool(default(Tool));
                    inputService.IsKeyboardHandled = true;
                }
            }

            var(cx, cy) = graphicsScreen.ToWorldCoordinates((int)_position.X, (int)_position.Y);

            if (!selection.Any())
            {
                return;
            }

            if (inputService.IsReleased(MouseButtons.Left) && selection.IsSelected(cx, cy, region))
            {
                var component = presenter.SelectedComponent;

                if (component != null)
                {
                    var componentType = component.GetType();
                    var floorTypes    = new List <String>()
                    {
                        "FloorComponent",
                        "WaterComponent",
                        "IceComponent",
                        "SkyComponent"
                    };
                    IEnumerable <TerrainComponent> similar = Enumerable.Empty <TerrainComponent>();

                    foreach (var area in selection)
                    {
                        for (var x = area.Left; x < area.Right; x++)
                        {
                            for (var y = area.Top; y < area.Bottom; y++)
                            {
                                var selectedTile = region.GetTile(x, y);

                                if (selectedTile == null)
                                {
                                    region.SetTile(x, y, selectedTile = new SegmentTile(x, y));
                                }

                                // Shift = Append; Alt = Replace
                                // if not shift and not alt, then clobber like components.
                                // if Shift, then there are no like components to clobber
                                // if Alt, then all components get clobbered.
                                // Alt wins in the case of shift+alt

                                if (!_isShiftDown && !_isAltDown)                         //not appending and not replacing.
                                {
                                    if (floorTypes.Contains(componentType.Name))
                                    {
                                        similar = selectedTile.GetComponents <TerrainComponent>(c => c is FloorComponent || c is WaterComponent || c is IceComponent || c is SkyComponent);
                                    }
                                    else
                                    {
                                        similar = selectedTile.GetComponents <TerrainComponent>(c => c.GetType().IsAssignableFrom(componentType));
                                    }
                                }
                                if (_isAltDown)                         // replacing
                                {
                                    similar = selectedTile.GetComponents <TerrainComponent>();
                                }

                                foreach (var similarComponent in similar)
                                {
                                    selectedTile.RemoveComponent(similarComponent);
                                }

                                selectedTile.Components.Add(component.Clone());
                                selectedTile.UpdateTerrain();
                            }
                        }
                    }

                    graphicsScreen.InvalidateRender();
                }
            }
        }