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);
}
