private void trySave(DrawableTile tile, TileActionType type, string timeString, string xString, string yString) { float time, x, y; try { time = float.Parse(timeString); x = float.Parse(xString); y = float.Parse(yString); } catch { notifications.Push("Make sure input is correct", NotificationState.Bad); return; } if (time < 0 && type == TileActionType.Movement) { notifications.Push("Negative time is not allowed for selected action type", NotificationState.Bad); return; } var action = new TileAction { EndX = x, EndY = y, Time = time, Type = type, }; Edited?.Invoke(tile, action); }
public override void Update(GameTime gameTime) { TransformationCounter += gameTime.ElapsedGameTime.TotalSeconds; if (TransformationCounter >= TilesTransformationCounter) { TransformationCounter -= TilesTransformationCounter; MapLayer ActiveLayer = Map.LayerManager.ListLayer[0]; for (int T = RealCurrentTransformingIndex; T < TerrainAttribute.ListTerrainChangeLocation.Count && T < RealCurrentTransformingIndex + _MinSimultaneousTiles; T++) { Terrain ActiveTerrain = TerrainAttribute.ListTerrainChangeLocation[T]; int PosX = (int)ActiveTerrain.Position.X; int PosY = (int)ActiveTerrain.Position.Y; DrawableTile ActiveTile = TerrainAttribute.ListTileChangeLocation[T]; ActiveLayer.ArrayTerrain[PosX, PosY] = ActiveTerrain; ActiveLayer.LayerGrid.ReplaceTile(PosX, PosY, ActiveTile); } CurrentTransformingIndex += _MinSimultaneousTiles; RealCurrentTransformingIndex = (int)CurrentTransformingIndex; Map.LayerManager.LayerHolderDrawable.Reset(); } if (RealCurrentTransformingIndex >= TerrainAttribute.ListTerrainChangeLocation.Count) { ExecuteEvent(this, 0); IsEnded = true; } }
public override void Update(GameTime gameTime) { TransformationCounter += gameTime.ElapsedGameTime.TotalSeconds; if (TransformationCounter >= TilesTransformationCounter) { TransformationCounter -= TilesTransformationCounter; int TilesetIndex = Map.ListTileSet.IndexOf(sprTileset); MapLayer ActiveLayer = Map.LayerManager.ListLayer[0]; for (int T = RealCurrentTransformingIndex; T < ListTerrainChangeLocation.Count && T < RealCurrentTransformingIndex + _MinSimultaneousTiles; T++) { Vector2 ActivePosition = ListTerrainChangeLocation[T]; int X = (int)ActivePosition.X; int Y = (int)ActivePosition.Y; DrawableTile ActiveTile = ActiveLayer.LayerGrid.GetTile(X, Y); ActiveTile.Origin = TerrainAttribute.Origin; ActiveTile.TilesetIndex = TilesetIndex; ActiveLayer.LayerGrid.ReplaceTile(X, Y, ActiveTile); } CurrentTransformingIndex += _MinSimultaneousTiles; RealCurrentTransformingIndex = (int)CurrentTransformingIndex; Map.LayerManager.LayerHolderDrawable.Reset(); } if (RealCurrentTransformingIndex >= ListTerrainChangeLocation.Count) { ExecuteEvent(this, 0); IsEnded = true; } }
public static bool Collided(Vector2 position, DrawableTile tile) { var playerPoints = createPlayerPoints(position); var trianglePoints1 = createTrianglePoints1(tile); var trianglePoints2 = createTrianglePoints2(tile); foreach (var t in trianglePoints1) { if (pointInPlayer(t, playerPoints)) { return(true); } } foreach (var r in playerPoints) { if (pointInTriangle(r, trianglePoints2)) { return(true); } } return(false); }
public void Update(GameTime gameTime) { UpdateCamera(); if (Map.CursorPositionVisible.X < 0) { Camera.CameraHeight = 600; Camera.CameraDistance = 500; Camera.SetTarget(new Vector3(Map.TileSize.X * Map.MapSize.X / 2, Map.CursorPosition.Z * 32, Map.TileSize.Y * Map.MapSize.Y / 2)); Camera.Update(gameTime); return; } Camera.CameraHeight = 400; Camera.CameraDistance = 300; int X = (int)Map.CursorPositionVisible.X; int Y = (int)Map.CursorPositionVisible.Y; float Z = Map.LayerManager.ListLayer[(int)Map.CursorPosition.Z].ArrayTerrain[X, Y].Position.Z * 32 + (Map.CursorPosition.Z * 32) + 0.3f; Map2D GroundLayer = Map.LayerManager.ListLayer[(int)Map.CursorPosition.Z].LayerGrid; DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y); Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo; Cursor = ActiveTerrain3D.CreateTile3D(0, Point.Zero, X * Map.TileSize.X, Y * Map.TileSize.Y, Z, Map.CursorPosition.Z * 32 + 0.3f, Map.TileSize, new List <Texture2D>() { sprCursor }, Z, Z, Z, Z, 0)[0]; Camera.SetTarget(new Vector3(Map.TileSize.X * Map.CursorPositionVisible.X, Map.CursorPosition.Z * 32, Map.TileSize.Y * Map.CursorPositionVisible.Y)); Camera.Update(gameTime); DicDrawablePointPerColor.Clear(); ListDrawableArrowPerColor.Clear(); }
public void UpdateActions(List <DrawableTile> tiles) { Clear(); foreach (var tile in tiles) { var action = tile.Tile.Action; if (action != null) { var halfSize = Vector2.Divide(DrawableTile.GetSize(tile.Tile.Type), new Vector2(2)); var start = new Vector2(tile.X, tile.Y) + halfSize; Vector2 end; switch (action.Type) { case TileActionType.Movement: Add(new BoxEndPoint(tile)); end = new Vector2(tile.Tile.Action.EndX, tile.Tile.Action.EndY) + halfSize; Add(new ConnectionLine(start, end)); break; case TileActionType.Rotation: Add(new EndPoint(tile)); end = new Vector2(tile.Tile.Action.EndX, tile.Tile.Action.EndY); Add(new ConnectionLine(start, end)); Add(new ConnectionCircle(tile) { Size = new Vector2(MathExtensions.Distance(start, end) * 2) }); break; } } } }
protected override string DoExecuteEffect() { if (!Params.LocalContext.Map.ListTileSet.Contains(sprTileset)) { Params.LocalContext.Map.ListTileSet.Add(sprTileset); } int TilesetIndex = Params.LocalContext.Map.ListTileSet.IndexOf(sprTileset); MapLayer ActiveLayer = Params.LocalContext.Map.ListLayer[Params.LocalContext.Map.ActiveLayerIndex]; foreach (Vector3 ActivePosition in Params.LocalContext.ArrayAttackPosition) { int X = (int)ActivePosition.X; int Y = (int)ActivePosition.Y; DrawableTile ActiveTile = ActiveLayer.OriginalLayerGrid.GetTile(X, Y); ActiveTile.Origin = TerrainAttribute.Origin; ActiveTile.Tileset = TilesetIndex; ActiveLayer.OriginalLayerGrid.ReplaceTile(X, Y, ActiveTile); } ActiveLayer.ResetGrid(); return(TerrainAttribute.Tileset + " (" + TerrainAttribute.Origin.X + ", " + TerrainAttribute.Origin.Y + ")"); }
private void tryDelete(DrawableTile tile) { confirmation.Push("Are you sure you want to delete action for this tile?", () => { Edited?.Invoke(tile, null); }); }
public void AddDrawablePath(List <MovementAlgorithmTile> ListPoint) { for (int P = 1; P < ListPoint.Count; P++) { MovementAlgorithmTile ActivePoint = ListPoint[P]; MovementAlgorithmTile Previous = ListPoint[P - 1]; MovementAlgorithmTile Next = null; if (P + 1 < ListPoint.Count) { Next = ListPoint[P + 1]; } int X = (int)ActivePoint.Position.X; int Y = (int)ActivePoint.Position.Y; float Z = Map.LayerManager.ListLayer[ActivePoint.LayerIndex].ArrayTerrain[X, Y].Position.Z * 32 + (ActivePoint.LayerIndex * 32) + 0.1f; Map2D GroundLayer = Map.LayerManager.ListLayer[ActivePoint.LayerIndex].LayerGrid; DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y); Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo; ListDrawableArrowPerColor.Add(ActiveTerrain3D.CreateTile3D(0, GetCursorTextureOffset(Previous, ActivePoint, Next), X * Map.TileSize.X, Y * Map.TileSize.Y, Z, Z + 0.15f, Map.TileSize, new List <Texture2D>() { Map.sprCursorPath }, Z, Z, Z, Z, 0)[0]); } }
private void UpdateBaseTile() { if (this.baseItem != null) { this.itemsLayer.Value.Items.Remove(this.baseItem); } if (this.mapModel == null) { this.baseTile = null; this.baseItem = null; return; } this.baseTile = new DrawableTile(this.mapModel.BaseTile); this.baseTile.BackgroundColor = Color.CornflowerBlue; this.baseTile.DrawHeightMap = this.model.HeightmapVisible; this.baseTile.SeaLevel = this.mapModel.SeaLevel; this.baseItem = new DrawableItem( 0, 0, -1, this.baseTile); this.baseItem.Locked = true; this.itemsLayer.Value.Items.Add(this.baseItem); }
protected virtual void CreateMap(SorcererStreetMap Map) { DicTile3D.Clear(); if (Map.ListTileSet.Count == 0) { return; } for (int X = Map.MapSize.X - 1; X >= 0; --X) { for (int Y = Map.MapSize.Y - 1; Y >= 0; --Y) { float Z = Grid.ArrayTerrain[X, Y].Position.Z; Vector3[] ArrayVertexPosition = new Vector3[4]; ArrayVertexPosition[0] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y); ArrayVertexPosition[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y); ArrayVertexPosition[2] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPosition[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y); Texture2D ActiveTileset = Map.ListTileSet[ActiveTerrain.TilesetIndex]; if (!DicTile3D.ContainsKey(ActiveTileset)) { DicTile3D.Add(ActiveTileset, new List <Tile3D>()); } DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPosition, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius)); //Create slope right if (X + 1 < Map.MapSize.X) { float ZRight = Grid.ArrayTerrain[X + 1, Y].Position.Z; if (Z != ZRight) { Vector3[] ArrayVertexPositionRight = new Vector3[4]; ArrayVertexPositionRight[0] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y); ArrayVertexPositionRight[2] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPositionRight[1] = new Vector3((X + 1) * Map.TileSize.X, ZRight, Y * Map.TileSize.Y); ArrayVertexPositionRight[3] = new Vector3((X + 1) * Map.TileSize.X, ZRight, Y * Map.TileSize.Y + Map.TileSize.Y); DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPositionRight, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius)); } } //Create slope down if (Y + 1 < Map.MapSize.Y) { float ZDown = Grid.ArrayTerrain[X, Y + 1].Position.Z; if (Z != ZDown) { Vector3[] ArrayVertexPositionDown = new Vector3[4]; ArrayVertexPositionDown[0] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPositionDown[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPositionDown[2] = new Vector3(X * Map.TileSize.X, ZDown, (Y + 1) * Map.TileSize.Y); ArrayVertexPositionDown[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, ZDown, (Y + 1) * Map.TileSize.Y); DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPositionDown, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius)); } } } } }
protected virtual void CreateMap(DeathmatchMap Map) { DicTile3D.Clear(); for (int X = Map.MapSize.X - 1; X >= 0; --X) { for (int Y = Map.MapSize.Y - 1; Y >= 0; --Y) { Map.GetTerrain(X, Y, Map.ActiveLayerIndex).Position.Z = Random.Next(2) * 32; float Z = Map.GetTerrain(X, Y, Map.ActiveLayerIndex).Position.Z; Vector3[] ArrayVertexPosition = new Vector3[4]; ArrayVertexPosition[0] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y); ArrayVertexPosition[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y); ArrayVertexPosition[2] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPosition[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); Map2D GroundLayer = Map.ListLayer[0].OriginalLayerGrid; DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y); Texture2D ActiveTileset = Map.ListTileSet[ActiveTerrain.Tileset]; if (!DicTile3D.ContainsKey(ActiveTileset)) { DicTile3D.Add(ActiveTileset, new List <Tile3D>()); } DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPosition, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius)); //Create slope right if (X + 1 < Map.MapSize.X) { float ZRight = Map.GetTerrain(X + 1, Y, Map.ActiveLayerIndex).Position.Z; if (Z != ZRight) { Vector3[] ArrayVertexPositionRight = new Vector3[4]; ArrayVertexPositionRight[0] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y); ArrayVertexPositionRight[2] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPositionRight[1] = new Vector3((X + 1) * Map.TileSize.X, ZRight, Y * Map.TileSize.Y); ArrayVertexPositionRight[3] = new Vector3((X + 1) * Map.TileSize.X, ZRight, Y * Map.TileSize.Y + Map.TileSize.Y); DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPositionRight, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius)); } } //Create slope down if (Y + 1 < Map.MapSize.Y) { float ZDown = Map.GetTerrain(X, Y + 1, Map.ActiveLayerIndex).Position.Z; if (Z != ZDown) { Vector3[] ArrayVertexPositionDown = new Vector3[4]; ArrayVertexPositionDown[0] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPositionDown[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPositionDown[2] = new Vector3(X * Map.TileSize.X, ZDown, (Y + 1) * Map.TileSize.Y); ArrayVertexPositionDown[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, ZDown, (Y + 1) * Map.TileSize.Y); DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPositionDown, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius)); } } } } }
/// <summary> /// Detects if tank is intersecting a impassible tile /// </summary> /// <param name="tankObject">Clients Tank</param> /// <returns>Collision</returns> private bool DetectCollision(PlayerTank tankObject) { // The 3 below this comment is an offset to make sure we only check for collisions with tiles // adjacent to us. Checks are done to a range of 3 tiles. int numTilesX = (viewportRect.X / Constants.TILE_SIZE) + 3; int numTilesY = (viewportRect.Y / Constants.TILE_SIZE) + 3; int minimumX = (int)(tankObject.Position.X / Constants.TILE_SIZE) - numTilesX; int minimumY = (int)(-tankObject.Position.Y / Constants.TILE_SIZE) - numTilesY; int maximumX = (int)(tankObject.Position.X / Constants.TILE_SIZE) + numTilesX; int maximumY = (int)(-tankObject.Position.Y / Constants.TILE_SIZE) + numTilesY; for (int y = minimumY; y < map.Height && y <= maximumY; y++) { if (y < 0) { continue; } for (int x = minimumX; x < map.Width && x <= maximumX; x++) { if (x < 0) { continue; } Options.KeyBindings keys = ServiceManager.Game.Options.KeySettings; DrawableTile tile = visibleTiles[y * map.Width + x]; if (tankObject.Name == PlayerManager.LocalPlayerName) { if (!tile.Passable && ( (Keyboard.GetState().IsKeyDown(keys.Forward) && tankObject.FrontSphere.Intersects(tile.BoundingBox)) || (Keyboard.GetState().IsKeyDown(keys.Backward) && tankObject.BackSphere.Intersects(tile.BoundingBox)))) { return(true); } } else { if (!tile.Passable && ((tankObject.FrontSphere.Intersects(tile.BoundingBox) && tankObject.DirectionMovement == VTankObject.Direction.FORWARD) || (tankObject.BackSphere.Intersects(tile.BoundingBox) && tankObject.DirectionMovement == VTankObject.Direction.REVERSE))) { return(true); } } } } return(false); }
protected void CreateMap(DeathmatchMap Map, MapLayer Owner, int LayerIndex) { Map2D GroundLayer = Owner.LayerGrid; for (int X = Map.MapSize.X - 1; X >= 0; --X) { for (int Y = Map.MapSize.Y - 1; Y >= 0; --Y) { DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y); Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo; if (ActiveTerrain3D.TerrainStyle == Terrain3D.TerrainStyles.Invisible) { continue; } float Z = Owner.ArrayTerrain[X, Y].Position.Z * 32 + (LayerIndex * 32); float ZFront = Z; float ZBack = Z; float ZRight = Z; float ZLeft = Z; if (Y + 1 < Map.MapSize.Y) { ZFront = Owner.ArrayTerrain[X, Y + 1].Position.Z * 32 + (LayerIndex * 32); } if (Y - 1 >= 0) { ZBack = Owner.ArrayTerrain[X, Y - 1].Position.Z * 32 + (LayerIndex * 32); } if (X - 1 >= 0) { ZLeft = Owner.ArrayTerrain[X - 1, Y].Position.Z * 32 + (LayerIndex * 32); } if (X + 1 < Map.MapSize.X) { ZRight = Owner.ArrayTerrain[X + 1, Y].Position.Z * 32 + (LayerIndex * 32); } List <Tile3D> ListNew3DTile = ActiveTerrain3D.CreateTile3D(ActiveTerrain.TilesetIndex, ActiveTerrain.Origin.Location, X * Map.TileSize.X, Y * Map.TileSize.Y, Z, LayerIndex * 32, Map.TileSize, Map.ListTileSet, ZFront, ZBack, ZLeft, ZRight, 0); foreach (Tile3D ActiveTile in ListNew3DTile) { if (!DicTile3DByTileset.ContainsKey(ActiveTile.TilesetIndex)) { DicTile3DByTileset.Add(ActiveTile.TilesetIndex, new Tile3DHolder(effect, Map.ListTileSet[ActiveTile.TilesetIndex])); } DicTile3DByTileset[ActiveTile.TilesetIndex].AddTile(ActiveTile); } } } for (int L = 0; L < Owner.ListSubLayer.Count; L++) { CreateMap(Map, Owner.ListSubLayer[L], LayerIndex); } }
public EndPoint(DrawableTile tile) { var action = tile.Tile.Action; Masking = true; Size = new Vector2(10); Origin = Anchor.Centre; Position = new Vector2(action.EndX, action.EndY); Colour = Color4.Red; }
public static Vector2 GetSnappedPosition(Vector2 input, int snapValue, TileType type) { var position = new Vector2((int)(input.X / snapValue), (int)(input.Y / snapValue)) * snapValue; if (type == TileType.Cherry || type == TileType.Jumprefresher) { position -= DrawableTile.GetSize(type) / 2f; } return(position); }
private void edit(DrawableTile tile) { if (selectedTilePlaceholder.Children.OfType <ActionEditor>().Any()) { return; } var actionEditor = new ActionEditor(tile.Tile.Action); selectedTilePlaceholder.Add(actionEditor); actionEditor.OnConfirm += actionParams => trySave(tile, actionParams.type, actionParams.time, actionParams.x, actionParams.y); }
protected override bool OnMouseMove(MouseMoveEvent e) { if (!IsHovered) { return(false); } mousePosition = e.MousePosition; var buttons = e.CurrentState.Mouse.Buttons; if (Tool.Value == ToolEnum.Select) { if (buttons.IsPressed(MouseButton.Left)) { var tile = TileToEdit.Value; if (tile != null) { tile.Position = GetSnappedPosition(mousePosition, SnapValue.Value, tile.Tile.Type); reselectTile(tile); objectsLayer.Save(); } } return(true); } if (!hoverLayer.Any()) { hoverLayer.Child = tileToPlace = createTile(new Tile { Type = Selected.Value }, room.Skin).With(t => { t.Alpha = 0.5f; }); } tileToPlace.Position = GetSnappedPosition(mousePosition, SnapValue.Value, Selected.Value); if (buttons.IsPressed(MouseButton.Left)) { objectsLayer.TryPlace(Selected.Value, mousePosition); return(true); } if (buttons.IsPressed(MouseButton.Right)) { objectsLayer.TryRemove(mousePosition); return(true); } return(base.OnMouseMove(e)); }
public void UpdateAction(DrawableTile tile, TileAction action) { foreach (var child in Tiles) { if (child == tile) { child.Tile.Action = action; break; } } Save(); }
public static bool CollidedWithCircle(Vector2 playerPosition, DrawableTile tile) { var radius = tile.Size.X / 2; var circlePosition = new Vector2(tile.Position.X + radius, tile.Position.Y + radius); var adjustedX = playerPosition.X - DefaultPlayer.SIZE.X / 2; var adjustedY = playerPosition.Y - DefaultPlayer.SIZE.Y / 2; var adjustedPlayerPosition = new Vector2(adjustedX, adjustedY); var deltaX = circlePosition.X - Math.Max(adjustedPlayerPosition.X, Math.Min(circlePosition.X, adjustedPlayerPosition.X + DefaultPlayer.SIZE.X)); var deltaY = circlePosition.Y - Math.Max(adjustedPlayerPosition.Y, Math.Min(circlePosition.Y, adjustedPlayerPosition.Y + DefaultPlayer.SIZE.Y)); return(MathExtensions.Pow(deltaX) + MathExtensions.Pow(deltaY) < MathExtensions.Pow(radius)); }
private Tile3D CreateTile(DeathmatchMap Map, Texture2D ActiveTileset, Vector3[] ArrayVertexPosition, int X, int Y) { //Add and remove a half pixel offset to avoid texture bleeding. VertexPositionColorTexture[] ArrayVertex = new VertexPositionColorTexture[4]; Map2D GroundLayer = Map.ListLayer[0].OriginalLayerGrid; DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y); float UVXValue = ActiveTerrain.Origin.X + 0.5f; float UVYValue = ActiveTerrain.Origin.Y + 0.5f; Vector2 TextureSize = new Vector2(ActiveTileset.Width, ActiveTileset.Height); ArrayVertex[0] = new VertexPositionColorTexture(); ArrayVertex[0].Position = ArrayVertexPosition[0]; ArrayVertex[0].TextureCoordinate = new Vector2(UVXValue / TextureSize.X, UVYValue / TextureSize.Y); ArrayVertex[0].Color = Color.White; UVXValue = ActiveTerrain.Origin.X + Map.TileSize.X - 0.5f; UVYValue = ActiveTerrain.Origin.Y + 0.5f; ArrayVertex[1] = new VertexPositionColorTexture(); ArrayVertex[1].Position = ArrayVertexPosition[1]; ArrayVertex[1].TextureCoordinate = new Vector2(UVXValue / TextureSize.X, UVYValue / TextureSize.Y); ArrayVertex[1].Color = Color.White; UVXValue = ActiveTerrain.Origin.X + 0.5f; UVYValue = ActiveTerrain.Origin.Y + Map.TileSize.Y - 0.5f; ArrayVertex[2] = new VertexPositionColorTexture(); ArrayVertex[2].Position = ArrayVertexPosition[2]; ArrayVertex[2].TextureCoordinate = new Vector2(UVXValue / TextureSize.X, UVYValue / TextureSize.Y); ArrayVertex[2].Color = Color.White; UVXValue = ActiveTerrain.Origin.X + Map.TileSize.X - 0.5f; UVYValue = ActiveTerrain.Origin.Y + Map.TileSize.Y - 0.5f; ArrayVertex[3] = new VertexPositionColorTexture(); ArrayVertex[3].Position = ArrayVertexPosition[3]; ArrayVertex[3].TextureCoordinate = new Vector2(UVXValue / TextureSize.X, UVYValue / TextureSize.Y); ArrayVertex[3].Color = Color.White; short[] ArrayIndex = new short[6]; ArrayIndex[0] = 0; ArrayIndex[1] = 1; ArrayIndex[2] = 3; ArrayIndex[3] = 0; ArrayIndex[4] = 3; ArrayIndex[5] = 2; Tile3D NewTile = new Tile3D(ArrayVertex, ArrayIndex); return(NewTile); }
public BoxEndPoint(DrawableTile tile) { var action = tile.Tile.Action; Size = tile.Size; Position = new Vector2(action.EndX, action.EndY); Masking = true; BorderColour = Color4.Red; BorderThickness = 3; AddInternal(new Box { RelativeSizeAxes = Axes.Both, Alpha = 0, AlwaysPresent = true }); }
private void onSelectedTileChanged(ValueChangedEvent <DrawableTile> tile) { if (tile.NewValue == null) { selectedTilePlaceholder.Clear(); return; } FillFlowContainer flow; selectedTilePlaceholder.Child = flow = new FillFlowContainer { RelativeSizeAxes = Axes.X, AutoSizeAxes = Axes.Y, Spacing = new Vector2(0, 10), Direction = FillDirection.Vertical, Children = new Drawable[] { new SpriteText { Text = tile.NewValue.Tile.Type.ToString() }, new SpriteText { Text = $"X: {tile.NewValue.X}" }, new SpriteText { Text = $"Y: {tile.NewValue.Y}" } } }; if (!DrawableTile.IsGroup(tile.NewValue, TileGroup.Spike) && tile.NewValue.Tile.Type != TileType.Cherry) { return; } var hasAction = tile.NewValue.Tile.Action != null; flow.Add(new EditorButton($"{(hasAction ? "Edit" : "Add")} action", () => edit(tile.NewValue))); if (hasAction) { flow.Add(new EditorButton("Delete action", () => tryDelete(tile.NewValue))); } }
public ConquestMap2D(ConquestMap Map) : base(Map) { ActiveMap = Map; DrawableTile[,] ArrayTile = new DrawableTile[MapSize.X, MapSize.Y]; for (int X = MapSize.X - 1; X >= 0; --X) { for (int Y = MapSize.Y - 1; Y >= 0; --Y) { ArrayTile[X, Y] = new DrawableTile(new Rectangle(0, 0, ActiveMap.TileSize.X, ActiveMap.TileSize.Y), 0); } } ReplaceGrid(ArrayTile); }
public SorcererStreetMap2D(SorcererStreetMap Map, List <AnimationBackground> ListBackgrounds, List <AnimationBackground> ListForegrounds) : base(Map, ListBackgrounds, ListForegrounds) { ActiveMap = Map; DrawableTile[,] ArrayTile = new DrawableTile[MapSize.X, MapSize.Y]; for (int X = MapSize.X - 1; X >= 0; --X) { for (int Y = MapSize.Y - 1; Y >= 0; --Y) { ArrayTile[X, Y] = new DrawableTile(new Rectangle(0, 0, ActiveMap.TileSize.X, ActiveMap.TileSize.Y), 0); } } ReplaceGrid(ArrayTile); }
public ConquestMap2D(ConquestMap Map, List <AnimationBackground> ListBackgrounds, List <AnimationBackground> ListForegrounds, BattleMapOverlay MapOverlay) : base(Map, ListBackgrounds, ListForegrounds, MapOverlay) { ActiveMap = Map; DrawableTile[,] ArrayTile = new DrawableTile[MapSize.X, MapSize.Y]; for (int X = MapSize.X - 1; X >= 0; --X) { for (int Y = MapSize.Y - 1; Y >= 0; --Y) { ArrayTile[X, Y] = new DrawableTile(new Rectangle(0, 0, ActiveMap.TileSize.X, ActiveMap.TileSize.Y), 0); } } ReplaceGrid(ArrayTile); }
protected override void CreateMap(DeathmatchMap Map) { DicTile3D.Clear(); for (int X = Map.MapSize.X - 1; X >= 0; --X) { for (int Y = Map.MapSize.Y - 1; Y >= 0; --Y) { Vector3[] ArrayVertexPosition = new Vector3[4]; ArrayVertexPosition[0] = new Vector3(X * Map.TileSize.X, 0, Y * Map.TileSize.Y); ArrayVertexPosition[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, 0, Y * Map.TileSize.Y); ArrayVertexPosition[2] = new Vector3(X * Map.TileSize.X, 0, Y * Map.TileSize.Y + Map.TileSize.Y); ArrayVertexPosition[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, 0, Y * Map.TileSize.Y + Map.TileSize.Y); Vector3[] ArrayTransformedVertexPosition = new Vector3[ArrayVertexPosition.Length]; Matrix TranslationToOriginMatrix = Matrix.CreateTranslation(-Radius, Radius, -Radius); Vector3.Transform(ArrayVertexPosition, ref TranslationToOriginMatrix, ArrayTransformedVertexPosition); for (int V = ArrayVertexPosition.Length - 1; V >= 0; --V) { ArrayVertexPosition[V] = ArrayTransformedVertexPosition[V]; } Map2D GroundLayer = Map.ListLayer[0].OriginalLayerGrid; DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y); Texture2D ActiveTileset = Map.ListTileSet[ActiveTerrain.Tileset]; if (!DicTile3D.ContainsKey(ActiveTileset)) { DicTile3D.Add(ActiveTileset, new List <Tile3D>()); } Tile3D NewTile = CreateTile(Map, ActiveTileset, ArrayVertexPosition, X, Y); if (Spherical) { MoveToSphericalCoordinates(NewTile, Radius); CreateSphericalElevation(Map, ActiveTileset, NewTile, X, Y); } else { CreateFlatElevation(Map, ActiveTileset, NewTile, X, Y); } CreateCubicTile(Map, ActiveTileset, NewTile); } } }
public DeathmatchMap2D(DeathmatchMap Map, MapLayer Owner) : base(Map) { ActiveMap = Map; this.Owner = Owner; DrawableTile[,] ArrayTile = new DrawableTile[MapSize.X, MapSize.Y]; for (int X = MapSize.X - 1; X >= 0; --X) { for (int Y = MapSize.Y - 1; Y >= 0; --Y) { ArrayTile[X, Y] = new DrawableTile(new Rectangle(0, 0, ActiveMap.TileSize.X, ActiveMap.TileSize.Y), 0); } } ReplaceGrid(ArrayTile); }
public ConnectionCircle(DrawableTile tile) { Origin = Anchor.Centre; Position = new Vector2(tile.Tile.Action.EndX, tile.Tile.Action.EndY); AddInternal(new CircularContainer { RelativeSizeAxes = Axes.Both, Masking = true, BorderColour = Color4.Red, BorderThickness = 3, Child = new Box { RelativeSizeAxes = Axes.Both, Alpha = 0, AlwaysPresent = true } }); }
private List <Tile> convertTiles(Room room, Vector2 newSize) { var oldTiles = room.Tiles; var newTiles = new List <Tile>(); foreach (var t in oldTiles) { if (t.PositionX + DrawableTile.GetSize(t.Type).X <= newSize.X * DrawableTile.SIZE) { if (t.PositionY + DrawableTile.GetSize(t.Type).Y <= newSize.Y * DrawableTile.SIZE) { newTiles.Add(t); } } } return(newTiles); }