michele/sledgemapper
1
0
Fork 0
Code Issues 5 Pull requests Projects Releases 4 Wiki Activity

more refactoring

Browse source
This commit is contained in:
Michele Scandura 2020-11-09 16:47:17 +00:00
parent d61f46d07a
commit 886d2a88b0
13 changed files with 592 additions and 573 deletions
Download patch file Download diff file Expand all files Collapse all files

595
Sledgemapper/Sledgemapper.cs
View file

@ -1,4 +1,4 @@
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.AspNetCore.SignalR.Client;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
@ -12,44 +12,23 @@ using System.Collections.Generic;
using System.IO;
using System.Linq;
using System;
using System.Collections.Concurrent;
using Sledgemapper.Shared.Entities;
using Refit;
using System.Net.Http;
using Polly.Retry;
using Polly.Timeout;
using Polly;
using Polly.Extensions.Http;
using System.Threading.Tasks;
using System.Net;
namespace Sledgemapper
{
public class Sledgemapper : Game
{
private CommunicationManager _communicationManager;
private State _state;
private GraphicsDeviceManager _graphics;
private SpriteBatch _spriteBatch;
private Tile _selectedTile = new Tile { X = 1, Y = 1 };
private Tile _hoveredTile = new Tile { X = 1, Y = 1 };
private Wall _selectedWall = new Wall { X = 1, Y = 1 };
private Overlay _selectedOverlay = new Overlay { X = 1, Y = 1 };
private int _tileSize = 30;
private HubConnection connection;
private AsyncRetryPolicy<HttpResponseMessage> retryPolicy;
private AsyncTimeoutPolicy<HttpResponseMessage> timeoutPolicy;
private readonly Desktop _desktop;
private string _currentTileId = "";
private string _currentWallId = "";
private string _currentOverlayId = "";
private InsertMode _insertMode;
private string _session;
private KeyboardState oldState;
private MouseState oldMouseState;
private Vector3 _viewportCenter = new Vector3(0, 0, 0);
private SpriteFont font;
private Dictionary<string, SpriteFont> _fonts;
private SessionData _sessionData;
private IMapApi _api;
private Session _sessionData;
public Sledgemapper()
{
@ -57,118 +36,19 @@ namespace Sledgemapper
Content.RootDirectory = "Content";
_desktop = new Desktop();
MyraEnvironment.Game = this;
_sessionData = new SessionData();
_sessionData = new Session();
IsFixedTimeStep = false;
_communicationManager = new CommunicationManager(_sessionData);
_state = new State();
}
protected override void Initialize()
{
// TODO: Add your initialization logic here
IsMouseVisible = true;
Window.AllowUserResizing = true;
Players = new List<Player>();
connection = new HubConnectionBuilder()
.WithAutomaticReconnect()
.WithUrl("http://localhost:5000/SledgemapperHub")
// .WithUrl("http://hub.michelescandura.com:5000/SledgemapperHub")
.Build();
retryPolicy = HttpPolicyExtensions
.HandleTransientHttpError()
.Or<TimeoutRejectedException>() // Thrown by Polly's TimeoutPolicy if the inner call gets timeout.
.WaitAndRetryAsync(2, _ => TimeSpan.FromMilliseconds(500));
timeoutPolicy = Policy
.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromMilliseconds(500));
var httpClientHandler = new HttpClientHandler();
//if (myConfigurationService.VerifySslCertificate == false)
//{
httpClientHandler.ServerCertificateCustomValidationCallback =
(message, certificate, chain, sslPolicyErrors) => true;
//}
_api = RestService.For<IMapApi>(
new HttpClient(httpClientHandler)
{
BaseAddress = new Uri("http://localhost:5000")
}
);
connection.On<SessionData>("UpdateMap", (map) =>
{
_sessionData.Map = map.Map;
_sessionData.Walls = map.Walls;
_sessionData.Overlays = map.Overlays;
});
connection.On<Player>("PlayerUpdate", (player) =>
{
var p = Players.FirstOrDefault(m => m.ConnectionId == player.ConnectionId);
if (p != null)
{
p.Position = player.Position;
}
});
connection.On<Tile>("DeleteTile", (tile) =>
{
_sessionData.Map.Remove(tile.ToString(), out var _);
});
connection.On<Wall>("DeleteWall", (tile) =>
{
_sessionData.Walls.Remove(tile.ToString(), out var _);
});
connection.On<Overlay>("DeleteOverlay", (tile) =>
{
_sessionData.Overlays.Remove(tile.ToString(), out var _);
});
connection.On<Tile>("NewTile", (tile) =>
{
_sessionData.Map.Remove(tile.ToString(), out var _);
_sessionData.Map.TryAdd(tile.ToString(), tile);
});
connection.On<Wall>("NewWall", (tile) =>
{
_sessionData.Walls.Remove(tile.ToString(), out var _);
_sessionData.Walls.TryAdd(tile.ToString(), tile);
});
connection.On<Overlay>("NewOverlay", (tile) =>
{
_sessionData.Overlays.Remove(tile.ToString(), out var _);
_sessionData.Overlays.TryAdd(tile.ToString(), tile);
});
connection.On<Player>("NewPlayer", (player) =>
{
var p = Players.FirstOrDefault(m => m.ConnectionId == player.ConnectionId);
if (p is null)
{
Players.Add(player);
}
else
{
p.Color = player.Color;
p.Position = player.Position;
}
});
base.Initialize();
}
public List<Player> Players { get; set; }
private HorizontalMenu BuildMenu()
{
var menu = new HorizontalMenu();
@ -240,25 +120,27 @@ namespace Sledgemapper
{
return;
}
if (connection.State != HubConnectionState.Connected)
{ await connection.StartAsync(); }
if (_communicationManager.Connection.State != HubConnectionState.Connected)
{ await _communicationManager.Connection.StartAsync(); }
var successful = false;
try
{
var result = await connection?.InvokeAsync<SessionData>("JoinSession", textbox.Text, initialsTextbox.Text);
var result = await _communicationManager.Connection?.InvokeAsync<Session>("JoinSession", textbox.Text, initialsTextbox.Text);
if (result != null)
{
_sessionData.Map = result.Map;
_sessionData.Walls = result.Walls;
_sessionData.Overlays = result.Overlays;
Players = result.Players;
_sessionData.Players = result.Players;
_sessionData.MapEntityAdded += OnMapEntityAdded;
}
successful = result != null; ;
}
catch { }
if (successful)
{
_session = textbox.Text;
_sessionData.SessionName = textbox.Text;
window.Close();
}
};
@ -311,34 +193,30 @@ namespace Sledgemapper
{
return;
}
if (connection.State != HubConnectionState.Connected)
{ await connection.StartAsync(); }
if (_communicationManager.Connection.State != HubConnectionState.Connected)
{ await _communicationManager.Connection.StartAsync(); }
var successful = false;
try
{
var session = await connection?.InvokeAsync<SessionData>("NewSession", textbox.Text, initialsTextbox.Text);
var session = await _communicationManager.Connection?.InvokeAsync<Session>("NewSession", textbox.Text, initialsTextbox.Text);
if (session != null)
{
_sessionData = session;
session.TileAdded += OnTileAdded;
session.OverlayAdded += OnOverlayAdded;
session.WallAdded += OnWallAdded;
session.TileDeleted += OnTileDeleted;
session.WallDeleted += OnWallDeleted;
session.OverlayDeleted += OnOverlayDeleted;
Players = session.Players;
_sessionData.SessionName = textbox.Text;
session.MapEntityAdded += OnMapEntityAdded;
session.Players = session.Players;
}
successful = session != null;
}
catch (Exception ex)
{
}
if (successful)
{
_session = textbox.Text;
_sessionData.SessionName = textbox.Text;
_communicationManager.SessionData = _sessionData;
window.Close();
}
};
@ -395,7 +273,7 @@ namespace Sledgemapper
using (StreamReader file = File.OpenText(dialog.FilePath))
{
JsonSerializer serializer = new JsonSerializer();
_sessionData = (SessionData)serializer.Deserialize(file, typeof(SessionData));
_sessionData = (Session)serializer.Deserialize(file, typeof(Session));
}
};
@ -404,7 +282,7 @@ namespace Sledgemapper
private async void OnMenuConnectSyncSelected(object sender, EventArgs e)
{
await connection?.InvokeAsync("Sync", _session, _sessionData);
await _communicationManager.Connection?.InvokeAsync("Sync", _sessionData.SessionName, _sessionData);
}
protected override void LoadContent()
@ -445,7 +323,7 @@ namespace Sledgemapper
var tileButton = new ImageButton { Image = new TextureRegion(item.Value), GridColumn = indexY, GridRow = indexX, Id = item.Key, Width = 40, Height = 40 };
tileButton.Click += (s, e) =>
{
_currentTileId = ((ImageButton)s).Id;
_state._currentTileId = ((ImageButton)s).Id;
ClearSelection(wallGrid);
ClearSelection(tileGrid);
@ -453,7 +331,7 @@ namespace Sledgemapper
((ImageButton)s).Border = new SolidBrush(Color.Red);
((ImageButton)s).BorderThickness = new Myra.Graphics2D.Thickness(2);
_insertMode = InsertMode.Tile;
_state._insertMode = InsertMode.Tile;
};
tileGrid.Widgets.Add(tileButton);
indexY++;
@ -473,7 +351,7 @@ namespace Sledgemapper
var wallButton = new ImageButton { Image = new TextureRegion(item.Value), GridColumn = indexY, GridRow = indexX, Id = item.Key, Width = 40, Height = 40 };
wallButton.Click += (s, e) =>
{
_currentWallId = ((ImageButton)s).Id;
_state._currentWallId = ((ImageButton)s).Id;
ClearSelection(wallGrid);
ClearSelection(tileGrid);
ClearSelection(overlayGrid);
@ -481,7 +359,7 @@ namespace Sledgemapper
((ImageButton)s).Border = new SolidBrush(Color.Red);
((ImageButton)s).BorderThickness = new Myra.Graphics2D.Thickness(2);
_insertMode = InsertMode.Wall;
_state._insertMode = InsertMode.Wall;
};
wallGrid.Widgets.Add(wallButton);
@ -502,16 +380,14 @@ namespace Sledgemapper
var overlayButton = new ImageButton { Image = new TextureRegion(item.Value), GridColumn = indexY, GridRow = indexX, Id = item.Key, Width = 40, Height = 40 };
overlayButton.Click += (s, e) =>
{
_currentOverlayId = ((ImageButton)s).Id;
_state._currentOverlayId = ((ImageButton)s).Id;
ClearSelection(wallGrid);
ClearSelection(tileGrid);
ClearSelection(overlayGrid);
((ImageButton)s).Border = new SolidBrush(Color.Red);
((ImageButton)s).BorderThickness = new Myra.Graphics2D.Thickness(2);
_insertMode = InsertMode.Overlay;
_state._insertMode = InsertMode.Overlay;
};
overlayGrid.Widgets.Add(overlayButton);
indexY++;
@ -529,7 +405,7 @@ namespace Sledgemapper
_desktop.Root = mainPanel;
// TODO: use this.Content to load your game content here
}
bool _draw;
protected override void Update(GameTime gameTime)
{
// if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
@ -542,55 +418,55 @@ namespace Sledgemapper
var screenPosition = new Point((mouseState.Position.X - (int)_viewportCenter.X), (mouseState.Position.Y - (int)_viewportCenter.Y));
_hoveredTile.X = screenPosition.X / _tileSize;
_hoveredTile.Y = screenPosition.Y / _tileSize;
_state._hoveredTile.X = screenPosition.X / _state._tileSize;
_state._hoveredTile.Y = screenPosition.Y / _state._tileSize;
if (screenPosition.X < 0)
{
_hoveredTile.X--;
_state._hoveredTile.X--;
}
if (screenPosition.Y < 0)
{
_hoveredTile.Y--;
_state._hoveredTile.Y--;
}
if (_insertMode == InsertMode.Wall)
if (_state._insertMode == InsertMode.Wall)
{
SelectClosestWall(screenPosition);
_state.SelectClosestWall(screenPosition);
}
if (_insertMode == InsertMode.Overlay)
if (_state._insertMode == InsertMode.Overlay)
{
SelectOverlay(screenPosition);
_state.SelectOverlay(screenPosition);
}
if (mouseState.LeftButton == ButtonState.Pressed && mouseState.LeftButton != oldMouseState.LeftButton)
{
_selectedTile.X = _hoveredTile.X;
_selectedTile.Y = _hoveredTile.Y;
connection?.SendAsync("UpdatePosition", _session, _selectedTile);
_state._selectedTile.X = _state._hoveredTile.X;
_state._selectedTile.Y = _state._hoveredTile.Y;
_communicationManager.Connection?.SendAsync("UpdatePosition", _sessionData.SessionName, _state._selectedTile);
}
if (newState.IsKeyDown(Keys.LeftControl)
&& mouseState.LeftButton == ButtonState.Pressed
&& ((mouseState.LeftButton != oldMouseState.LeftButton) || (_selectedTile.X != _hoveredTile.X && _selectedTile.Y != _hoveredTile.Y)))
&& ((mouseState.LeftButton != oldMouseState.LeftButton) || (_state._selectedTile.X != _state._hoveredTile.X && _state._selectedTile.Y != _state._hoveredTile.Y)))
{
switch (_insertMode)
switch (_state._insertMode)
{
case InsertMode.Tile:
_selectedTile.X = _hoveredTile.X;
_selectedTile.Y = _hoveredTile.Y;
connection?.SendAsync("UpdatePosition", _session, _selectedTile);
_state._selectedTile.X = _state._hoveredTile.X;
_state._selectedTile.Y = _state._hoveredTile.Y;
_communicationManager.Connection?.SendAsync("UpdatePosition", _sessionData.SessionName, _state._selectedTile);
_sessionData.NewTile(_selectedTile, _currentTileId);
_sessionData.NewTile(_state._selectedTile, _state._currentTileId);
break;
case InsertMode.Wall:
_sessionData.NewWall(_selectedWall, _currentWallId);
_sessionData.NewWall(_state._selectedWall, _state._currentWallId);
break;
case InsertMode.Overlay:
_sessionData.NewOverlay(_selectedOverlay, _currentOverlayId);
_sessionData.NewOverlay(_state._selectedOverlay, _state._currentOverlayId);
break;
}
}
@ -604,12 +480,12 @@ namespace Sledgemapper
{
if (mouseState.ScrollWheelValue > oldMouseState.ScrollWheelValue)
{
_tileSize = System.Math.Min(120, _tileSize + 10);
_state._tileSize = Math.Min(120, _state._tileSize + 10);
}
else if (mouseState.ScrollWheelValue < oldMouseState.ScrollWheelValue)
{
_tileSize = System.Math.Max(10, _tileSize - 10);
_state._tileSize = Math.Max(10, _state._tileSize - 10);
}
}
@ -619,18 +495,18 @@ namespace Sledgemapper
if (newState.IsKeyDown(Keys.Delete))
{
switch (_insertMode)
switch (_state._insertMode)
{
case InsertMode.Tile:
_selectedTile.X = _hoveredTile.X;
_selectedTile.Y = _hoveredTile.Y;
_sessionData.DeleteTile(_selectedTile);
_state._selectedTile.X = _state._hoveredTile.X;
_state._selectedTile.Y = _state._hoveredTile.Y;
_sessionData.DeleteTile(_state._selectedTile);
break;
case InsertMode.Wall:
_sessionData.DeleteWall(_selectedWall);
_sessionData.DeleteWall(_state._selectedWall);
break;
case InsertMode.Overlay:
_sessionData.DeleteOverlay(_selectedOverlay);
_sessionData.DeleteOverlay(_state._selectedOverlay);
break;
}
}
@ -641,22 +517,22 @@ namespace Sledgemapper
{
case Keys.Left:
if (oldState.IsKeyUp(Keys.Left) && newState.IsKeyDown(Keys.Left))
{ _selectedTile.X--; }
{ _state._selectedTile.X--; }
break;
case Keys.Right:
if (oldState.IsKeyUp(Keys.Right) && newState.IsKeyDown(Keys.Right))
{ _selectedTile.X++; }
{ _state._selectedTile.X++; }
break;
case Keys.Up:
if (oldState.IsKeyUp(Keys.Up) && newState.IsKeyDown(Keys.Up))
{ _selectedTile.Y--; }
{ _state._selectedTile.Y--; }
break;
case Keys.Down:
if (oldState.IsKeyUp(Keys.Down) && newState.IsKeyDown(Keys.Down))
{ _selectedTile.Y++; }
{ _state._selectedTile.Y++; }
break;
}
connection?.SendAsync("UpdatePosition", _session, _selectedTile);
_communicationManager.Connection?.SendAsync("UpdatePosition", _sessionData.SessionName, _state._selectedTile);
}
@ -672,24 +548,57 @@ namespace Sledgemapper
return;
}
GraphicsDevice.Clear(Color.DarkGray);
var sessionData = _sessionData;
// TODO: Add your drawing code here
var visibleTilesX = GraphicsDevice.Viewport.Width / _tileSize + 1;
var visibleTilesY = GraphicsDevice.Viewport.Height / _tileSize + 1;
var visibleTilesX = GraphicsDevice.Viewport.Width / _state._tileSize + 1;
var visibleTilesY = GraphicsDevice.Viewport.Height / _state._tileSize + 1;
_spriteBatch.Begin(transformMatrix: Matrix.CreateTranslation(_viewportCenter));
DrawGrid(visibleTilesX, visibleTilesY);
DrawTiles();
DrawWalls();
DrawOverlays();
if (string.IsNullOrWhiteSpace(_sessionData.SessionName))
{
_spriteBatch.DrawRectangle(new Rectangle(_state._selectedTile.X * _state._tileSize, _state._selectedTile.Y * _state._tileSize, _state._tileSize - 1, _state._tileSize - 1), Color.Red, 2);
}
DrawPlayers();
var startWall = new Vector2(_state._selectedWall.X * _state._tileSize, _state._selectedWall.Y * _state._tileSize);
if (_state._insertMode == InsertMode.Wall)
{
_spriteBatch.DrawLine(startWall, _state._tileSize, MathHelper.ToRadians(90 * _state._selectedWall.Rotation), Color.Red, 2);
}
var overlay = new Vector2(_state._selectedOverlay.X * _state._tileSize, _state._selectedOverlay.Y * _state._tileSize);
if (_state._insertMode == InsertMode.Overlay)
{
if (_state._selectedOverlay.Intersection)
{
_spriteBatch.DrawCircle(overlay, _state._tileSize / 3, 100, Color.Red, 2);
}
}
_spriteBatch.End();
_desktop?.Render();
base.Draw(gameTime);
}
private void DrawGrid(int visibleTilesX, int visibleTilesY)
{
for (var i = -1; i < visibleTilesX + 2; i++)
{
var posX1 = i * _tileSize - _viewportCenter.X;
var posX1 = i * _state._tileSize - _viewportCenter.X;
var posY1 = -_viewportCenter.Y;
posX1 = posX1 - posX1 % _tileSize;
posY1 = posY1 - posY1 % _tileSize;
var posX2 = i * _tileSize - _viewportCenter.X;
posX1 = posX1 - posX1 % _state._tileSize;
posY1 = posY1 - posY1 % _state._tileSize;
var posX2 = i * _state._tileSize - _viewportCenter.X;
var posY2 = GraphicsDevice.Viewport.Height - _viewportCenter.Y;
posX2 = posX2 - posX2 % _tileSize;
posY2 = posY2 - posY2 % _tileSize;
posX2 = posX2 - posX2 % _state._tileSize;
posY2 = posY2 - posY2 % _state._tileSize;
_spriteBatch.DrawLine(
posX1, posY1,
@ -701,41 +610,93 @@ namespace Sledgemapper
for (var i = -1; i < visibleTilesY + 2; i++)
{
var posX1 = -_viewportCenter.X;
var posY1 = i * _tileSize - _viewportCenter.Y;
posX1 = posX1 - posX1 % _tileSize;
posY1 = posY1 - posY1 % _tileSize;
var posY1 = i * _state._tileSize - _viewportCenter.Y;
posX1 = posX1 - posX1 % _state._tileSize;
posY1 = posY1 - posY1 % _state._tileSize;
var posX2 = GraphicsDevice.Viewport.Width - _viewportCenter.X;
var posY2 = i * _tileSize - _viewportCenter.Y;
posX2 = posX2 - posX2 % _tileSize;
posY2 = posY2 - posY2 % _tileSize;
var posY2 = i * _state._tileSize - _viewportCenter.Y;
posX2 = posX2 - posX2 % _state._tileSize;
posY2 = posY2 - posY2 % _state._tileSize;
_spriteBatch.DrawLine(posX1, posY1,
posX2,
posY2,
Color.Black);
}
}
foreach (var tile in sessionData.Map.Values)
private void DrawTiles()
{
foreach (var tile in _sessionData.Map.Values)
{
var content = Content.Load<Texture2D>($"tiles/{tile.ID}");
var destinationRectangle = new Rectangle(tile.X * _tileSize, tile.Y * _tileSize, _tileSize, _tileSize);
var posX = tile.X * _tileSize + _tileSize / 2f;
var posY = tile.Y * _tileSize + _tileSize / 2f;
var posX = tile.X * _state._tileSize + _state._tileSize / 2f;
var posY = tile.Y * _state._tileSize + _state._tileSize / 2f;
_spriteBatch.Draw(content, new Vector2(posX, posY),
null, Color.White, MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_tileSize - 1) / content.Width, SpriteEffects.None, 0);
null, Color.White, MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_state._tileSize - 1) / content.Width, SpriteEffects.None, 0);
}
}
foreach (var wall in sessionData.Walls.Values)
private void DrawPlayers()
{
foreach (var player in _sessionData.Players.Copy<List<Player>>())
{
var hexs = player.Color.Split(2).ToArray();
var color = new Color(int.Parse(hexs[0], System.Globalization.NumberStyles.HexNumber),
int.Parse(hexs[1], System.Globalization.NumberStyles.HexNumber),
int.Parse(hexs[2], System.Globalization.NumberStyles.HexNumber));
_spriteBatch.DrawRectangle(new Rectangle(player.Position.X * _state._tileSize, player.Position.Y * _state._tileSize, _state._tileSize - 1, _state._tileSize - 1), color, 2);
var ffont = _fonts.FirstOrDefault(m => int.Parse(m.Key.Replace("font", "")) > _state._tileSize).Value ?? _fonts.Last().Value;
var fscale = (float)_state._tileSize / ((float)ffont.LineSpacing * 2);
_spriteBatch.DrawString(ffont,
player.Initials,
new Vector2(player.Position.X * _state._tileSize + 2, player.Position.Y * _state._tileSize + _state._tileSize - 2 - ffont.LineSpacing * fscale),
color,
0,
Vector2.Zero,
fscale,
SpriteEffects.None,
0);
}
}
private void DrawOverlays()
{
foreach (var tile in _sessionData.Overlays.Values)
{
var content = Content.Load<Texture2D>($"overlays/{tile.ID}");
if (tile.Intersection)
{
var posX = tile.X * _state._tileSize;
var posY = tile.Y * _state._tileSize;
_spriteBatch.Draw(content, new Vector2(posX, posY),
null, new Color(24, 118, 157), MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_state._tileSize - 10) / content.Width, SpriteEffects.None, 0);
}
else
{
var posX = tile.X * _state._tileSize + _state._tileSize / 2f;
var posY = tile.Y * _state._tileSize + _state._tileSize / 2f;
_spriteBatch.Draw(content, new Vector2(posX, posY),
null, new Color(24, 118, 157), MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_state._tileSize - 10) / content.Width, SpriteEffects.None, 0);
}
}
}
private void DrawWalls()
{
foreach (var wall in _sessionData.Walls.Values)
{
var content = Content.Load<Texture2D>($"walls/{wall.ID}");
var scale = _tileSize / (float)content.Height;
var scale = _state._tileSize / (float)content.Height;
var offset = scale * content.Width / 2f;
var posX = wall.X * _tileSize;
var posY = wall.Y * _tileSize;
var posX = wall.X * _state._tileSize;
var posY = wall.Y * _state._tileSize;
if (wall.Rotation == 1)
{
posX -= (int)offset;
@ -744,82 +705,8 @@ namespace Sledgemapper
{
posY += (int)offset;
}
// _spriteBatch.Draw(content, new Vector2(posX, posY),null, Color.White, MathHelper.ToRadians(90 * (wall.Rotation - 1)), new Vector2(offset, 0), scale, SpriteEffects.None, 0);
_spriteBatch.Draw(content, new Vector2(posX, posY), null, Color.White, MathHelper.ToRadians(90 * (wall.Rotation - 1)), new Vector2(0, 0), scale, SpriteEffects.None, 0);
}
foreach (var tile in sessionData.Overlays.Values)
{
var content = Content.Load<Texture2D>($"overlays/{tile.ID}");
// System.Console.WriteLine(tile.Rotation);
if (tile.Intersection)
{
var posX = tile.X * _tileSize;
var posY = tile.Y * _tileSize;
_spriteBatch.Draw(content, new Vector2(posX, posY),
null, new Color(24, 118, 157), MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_tileSize - 10) / content.Width, SpriteEffects.None, 0);
}
else
{
var posX = tile.X * _tileSize + _tileSize / 2f;
var posY = tile.Y * _tileSize + _tileSize / 2f;
_spriteBatch.Draw(content, new Vector2(posX, posY),
null, new Color(24, 118, 157), MathHelper.ToRadians(90 * tile.Rotation), new Vector2(content.Width / 2, content.Height / 2), ((float)_tileSize - 10) / content.Width, SpriteEffects.None, 0);
}
}
if (string.IsNullOrWhiteSpace(_session))
{
_spriteBatch.DrawRectangle(new Rectangle(_selectedTile.X * _tileSize, _selectedTile.Y * _tileSize, _tileSize - 1, _tileSize - 1), Color.Red, 2);
}
foreach (var player in Players.Copy<List<Player>>())
{
var hexs = player.Color.Split(2).ToArray();
var color = new Color(int.Parse(hexs[0], System.Globalization.NumberStyles.HexNumber),
int.Parse(hexs[1], System.Globalization.NumberStyles.HexNumber),
int.Parse(hexs[2], System.Globalization.NumberStyles.HexNumber));
_spriteBatch.DrawRectangle(new Rectangle(player.Position.X * _tileSize, player.Position.Y * _tileSize, _tileSize - 1, _tileSize - 1), color, 2);
var ffont = _fonts.FirstOrDefault(m => int.Parse(m.Key.Replace("font", "")) > _tileSize).Value ?? _fonts.Last().Value;
var fscale = (float)_tileSize / ((float)ffont.LineSpacing * 2);
_spriteBatch.DrawString(ffont,
player.Initials,
new Vector2(player.Position.X * _tileSize + 2, player.Position.Y * _tileSize + _tileSize - 2 - ffont.LineSpacing * fscale),
color,
0,
Vector2.Zero,
fscale,
SpriteEffects.None,
0);
}
var startWall = new Vector2(_selectedWall.X * _tileSize, _selectedWall.Y * _tileSize);
if (_insertMode == InsertMode.Wall)
{
_spriteBatch.DrawLine(startWall, _tileSize, MathHelper.ToRadians(90 * _selectedWall.Rotation), Color.Red, 2);
}
var overlay = new Vector2(_selectedOverlay.X * _tileSize, _selectedOverlay.Y * _tileSize);
if (_insertMode == InsertMode.Overlay)
{
if (_selectedOverlay.Intersection)
{
_spriteBatch.DrawCircle(overlay, _tileSize / 3, 100, Color.Red, 2);
}
}
_spriteBatch.End();
_desktop?.Render();
base.Draw(gameTime);
}
private void ClearSelection(Grid grid)
@ -830,136 +717,20 @@ namespace Sledgemapper
}
}
private float Sign(Point p1, Point p2, Point p3) { return (p1.X - p3.X) * (p2.Y - p3.Y) - (p2.X - p3.X) * (p1.Y - p3.Y); }
private bool PointInTri(Point pt, Point v1, Point v2, Point v3)
private void OnMapEntityAdded(object sender, MapEntityAddedEventArgs e)
{
bool b1, b2, b3;
b1 = Sign(pt, v1, v2) < 0.0f;
b2 = Sign(pt, v2, v3) < 0.0f;
b3 = Sign(pt, v3, v1) < 0.0f;
return ((b1 == b2) && (b2 == b3));
_communicationManager.Enqueue(e.MapEntity, TileAction.Add);
}
private void SelectClosestWall(Point mousePosition)
private void OnMapEntityDeleted(object sender, MapEntityDeletedEventArgs e)
{
var topLeft = new Point(_hoveredTile.X * _tileSize, _hoveredTile.Y * _tileSize);
var bottomLeft = new Point(_hoveredTile.X * _tileSize, _hoveredTile.Y * _tileSize + _tileSize);
var topRight = new Point(_hoveredTile.X * _tileSize + _tileSize, _hoveredTile.Y * _tileSize);
var bottomRight = new Point(_hoveredTile.X * _tileSize + _tileSize, _hoveredTile.Y * _tileSize + _tileSize);
var center = new Point(_hoveredTile.X * _tileSize + _tileSize / 2, _hoveredTile.Y * _tileSize + _tileSize / 2);
var leftWall = PointInTri(mousePosition, topLeft, center, bottomLeft);
var rightWall = PointInTri(mousePosition, topRight, bottomRight, center);
var topWall = PointInTri(mousePosition, topLeft, topRight, center);
var bottomtWall = PointInTri(mousePosition, bottomLeft, center, bottomRight);
if (leftWall)
{
_selectedWall.X = _hoveredTile.X;
_selectedWall.Y = _hoveredTile.Y;
_selectedWall.Rotation = 1;
}
else if (rightWall)
{
_selectedWall.X = _hoveredTile.X + 1;
_selectedWall.Y = _hoveredTile.Y;
_selectedWall.Rotation = 1;
}
else if (topWall)
{
_selectedWall.X = _hoveredTile.X;
_selectedWall.Y = _hoveredTile.Y;
_selectedWall.Rotation = 0;
}
else if (bottomtWall)
{
_selectedWall.X = _hoveredTile.X;
_selectedWall.Y = _hoveredTile.Y + 1;
_selectedWall.Rotation = 0;
}
}
private void SelectOverlay(Point mousePosition)
{
_selectedOverlay.X = _hoveredTile.X;
_selectedOverlay.Y = _hoveredTile.Y;
var q1 = System.Math.Pow(mousePosition.X - _hoveredTile.X * _tileSize, 2);
var q2 = System.Math.Pow((_hoveredTile.Y * _tileSize - mousePosition.Y), 2);
var s = System.Math.Sqrt(q1 + q2);
if (s < _tileSize / 3)
{
_selectedOverlay.Intersection = true;
return;
}
q1 = System.Math.Pow(mousePosition.X - (_hoveredTile.X + 1) * _tileSize, 2);
// var q2 = System.Math.Pow((_hoveredTile.Y * _tileSize - mousePosition.Y), 2);
s = System.Math.Sqrt(q1 + q2);
if (s < _tileSize / 3)
{
_selectedOverlay.X = _selectedOverlay.X + 1;
_selectedOverlay.Intersection = true;
return;
}
//q1 = System.Math.Pow(mousePosition.X - (_hoveredTile.X + 1) * _tileSize, 2);
q2 = System.Math.Pow(((_hoveredTile.Y + 1) * _tileSize - mousePosition.Y), 2);
s = System.Math.Sqrt(q1 + q2);
if (s < _tileSize / 3)
{
_selectedOverlay.X = _selectedOverlay.X + 1;
_selectedOverlay.Y = _selectedOverlay.Y + 1;
_selectedOverlay.Intersection = true;
return;
}
q1 = System.Math.Pow(mousePosition.X - _hoveredTile.X * _tileSize, 2);
q2 = System.Math.Pow(((_hoveredTile.Y + 1) * _tileSize - mousePosition.Y), 2);
s = System.Math.Sqrt(q1 + q2);
if (s < _tileSize / 3)
{
_selectedOverlay.X = _selectedOverlay.X;
_selectedOverlay.Y = _selectedOverlay.Y + 1;
_selectedOverlay.Intersection = true;
return;
}
_selectedOverlay.Intersection = false;
}
private async Task Execute(Func<Task> call)
{
await Policy
.Handle<ApiException>(ex => ex.StatusCode == HttpStatusCode.RequestTimeout)
.RetryAsync(5, async (exception, retryCount) => await Task.Delay(500))
.ExecuteAsync(async () => await call().ConfigureAwait(false))
.ConfigureAwait(false);
}
private async void OnOverlayAdded(object sender, OverlayAddedEventArgs e)
{
await Execute(() => _api.NewOverlay(e.Overlay, _session));
}
private void OnTileAdded(object sender, TileAddedEventArgs e)
{
_api.NewTile(e.Tile, _session);
}
private void OnWallAdded(object sender, WallAddedEventArgs e)
{
_api.NewWall(e.Wall, _session);
}
private void OnOverlayDeleted(object sender, OverlayDeletedEventArgs e)
{
_api.DeleteOverlay(e.Overlay, _session);
}
private void OnTileDeleted(object sender, TileDeletedEventArgs e)
{
_api.DeleteTile(e.Tile, _session);
}
private void OnWallDeleted(object sender, WallDeletedEventArgs e)
{
_api.DeleteWall(e.Wall, _session);
_communicationManager.Enqueue(e.MapEntity, TileAction.Delete);
}
}
public enum TileAction
{
Add,
Delete
}
}