434 lines
18 KiB
C#
434 lines
18 KiB
C#
using Microsoft.Win32;
|
|
using RBG.Helpers;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Controls.Primitives;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Effects;
|
|
using System.Windows.Media.Imaging;
|
|
using System.Windows.Shapes;
|
|
|
|
namespace RBG_Server.WPF
|
|
{
|
|
|
|
/// <summary>
|
|
/// Interaction logic for MainWindow.xaml
|
|
/// </summary>
|
|
public partial class MainWindow : Window
|
|
{
|
|
// Global Styles etc
|
|
private static readonly SolidColorBrush borderBrush = new(Color.FromRgb(255, 0, 0));
|
|
|
|
|
|
GameServer gameServer;
|
|
// Game board bytes
|
|
byte[] gameBoard;
|
|
|
|
public MainWindow()
|
|
{
|
|
InitializeComponent();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Browse for file button
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void BrowseButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
OpenFileDialog ofd = new();
|
|
ofd.Filter = "Image Files|*.png;*.jpg";
|
|
if (ofd.ShowDialog() == true)
|
|
{
|
|
ImageSourceTextBox.Text = ofd.FileName;
|
|
UpdateImage();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update the image when the text box looses focus
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void ImageSourceTextBox_LostFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
UpdateImage();
|
|
}
|
|
|
|
private void UpdateImage()
|
|
{
|
|
try
|
|
{
|
|
using FileStream fs = File.OpenRead(ImageSourceTextBox.Text);
|
|
using MemoryStream ms = new();
|
|
fs.CopyTo(ms); // Load into memory, so the server can also utilise the stream
|
|
gameBoard = ms.ToArray();
|
|
|
|
BitmapImage gameBoardImage = new();
|
|
gameBoardImage.BeginInit();
|
|
gameBoardImage.StreamSource = new MemoryStream(gameBoard, false);
|
|
//gameBoardImage.CacheOption = BitmapCacheOption.OnLoad; // Must preload the image into memory, before it is unloaded
|
|
gameBoardImage.EndInit();
|
|
PreviewImage.Source = gameBoardImage;
|
|
RedrawGrid();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Creates and starts the game server
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void StartServerButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
gameServer = new((byte)StartingRow.Value, (byte)StartingColumn.Value, (byte)NumberOfRows.Value, (byte)NumberOfColumns.Value, (byte)ZoomBoxStartRow.Value, (byte)ZoomBoxStartColumn.Value, (byte)ZoomBoxSpan.Value, (byte)ZoomBoxSpan.Value, gameBoard);
|
|
}
|
|
|
|
|
|
private void NumberOfRows_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
|
|
{
|
|
if (IsInitialized)
|
|
{
|
|
StartingRow.Maximum = NumberOfRows.Value;
|
|
ZoomBoxStartRow.Maximum = NumberOfRows.Value;
|
|
ZoomBoxSpan.Maximum = Math.Min(NumberOfRows.Value - ZoomBoxStartRow.Value, NumberOfColumns.Value - ZoomBoxStartColumn.Value);
|
|
RedrawGrid();
|
|
}
|
|
}
|
|
|
|
private void NumberOfColumns_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
|
|
{
|
|
if (IsInitialized)
|
|
{
|
|
StartingColumn.Maximum = NumberOfColumns.Value;
|
|
ZoomBoxStartColumn.Maximum = NumberOfColumns.Value;
|
|
ZoomBoxSpan.Maximum = Math.Min(NumberOfRows.Value - ZoomBoxStartRow.Value, NumberOfColumns.Value - ZoomBoxStartColumn.Value);
|
|
RedrawGrid();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Draws the overlay grid, clearing existing elements if necessary
|
|
/// </summary>
|
|
private void RedrawGrid()
|
|
{
|
|
|
|
PreviewImageOverlay.RowDefinitions.Clear();
|
|
PreviewImageOverlay.ColumnDefinitions.Clear();
|
|
PreviewImageOverlay.Children.Clear();
|
|
for (int i = 0; i < NumberOfColumns.Value; i++)
|
|
{
|
|
PreviewImageOverlay.ColumnDefinitions.Add(new ColumnDefinition());
|
|
}
|
|
for (int i = 0; i < NumberOfRows.Value; i++)
|
|
{
|
|
PreviewImageOverlay.RowDefinitions.Add(new RowDefinition());
|
|
}
|
|
// Draw the overlay
|
|
Rectangle overlay = new();
|
|
overlay.Fill = new SolidColorBrush(Color.FromArgb(128, 0, 128, 255));
|
|
_ = PreviewImageOverlay.Children.Add(overlay);
|
|
Grid.SetRow(overlay, (int)ZoomBoxStartRow.Value);
|
|
Grid.SetColumn(overlay, (int)ZoomBoxStartColumn.Value);
|
|
Grid.SetRowSpan(overlay, (int)ZoomBoxSpan.Value);
|
|
Grid.SetColumnSpan(overlay, (int)ZoomBoxSpan.Value);
|
|
// Draw the starting position
|
|
overlay = new();
|
|
overlay.Fill = new SolidColorBrush(Color.FromArgb(64, 0, 255, 128));
|
|
_ = PreviewImageOverlay.Children.Add(overlay);
|
|
Grid.SetRow(overlay, (int)StartingRow.Value);
|
|
Grid.SetColumn(overlay, (int)StartingColumn.Value);
|
|
// Draw grids onto the preview image
|
|
for (int v = 0; v < PreviewImageOverlay.RowDefinitions.Count; v++)
|
|
{
|
|
for (int u = 0; u < PreviewImageOverlay.ColumnDefinitions.Count; u++)
|
|
{
|
|
Border border = new();
|
|
border.BorderBrush = borderBrush;
|
|
border.BorderThickness = new Thickness(2);
|
|
_ = PreviewImageOverlay.Children.Add(border);
|
|
Grid.SetRow(border, v);
|
|
Grid.SetColumn(border, u);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates the game board overlay grid
|
|
/// The grid should be appropriately sized before using this
|
|
/// </summary>
|
|
private void GenerateGameBoard(List<Player> players)
|
|
{
|
|
// Create an array of BoardCells Rows*Columns in size
|
|
BoardCell[] cells = new BoardCell[PreviewImageOverlay.RowDefinitions.Count * PreviewImageOverlay.ColumnDefinitions.Count];
|
|
List<Player> unaddedPlayers = players;
|
|
for (int i = 0; i < cells.Length; i++)
|
|
{
|
|
cells[i] = new BoardCell();
|
|
Queue<Player> removedPlayers = new();
|
|
foreach (Player item in unaddedPlayers)
|
|
{
|
|
if ((item.Row * PreviewImageOverlay.ColumnDefinitions.Count) + item.Column == i)
|
|
{
|
|
removedPlayers.Enqueue(item);
|
|
}
|
|
}
|
|
while (removedPlayers.Count > 0)
|
|
{
|
|
Player removed = removedPlayers.Dequeue();
|
|
_ = unaddedPlayers.Remove(removed);
|
|
_ = cells[i].CellStack.Children.Add(removed);
|
|
}
|
|
_ = PreviewImageOverlay.Children.Add(cells[i]);
|
|
cells[i].CellButton.Tag = new Tuple<int, int>(i % PreviewImageOverlay.ColumnDefinitions.Count, i / PreviewImageOverlay.ColumnDefinitions.Count);
|
|
Grid.SetColumn(cells[i], i % PreviewImageOverlay.ColumnDefinitions.Count);
|
|
Grid.SetRow(cells[i], i / PreviewImageOverlay.ColumnDefinitions.Count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a cell on the board; as a grid
|
|
/// </summary>
|
|
class BoardCell : Grid
|
|
{
|
|
// brush the button should have
|
|
|
|
static SolidColorBrush buttonBrush = new(Color.FromArgb(1, 255, 255, 255));
|
|
|
|
|
|
// Each cell has a uniform grid that
|
|
public UniformGrid CellStack { get; } = new()
|
|
{
|
|
Columns = 4,
|
|
HorizontalAlignment = HorizontalAlignment.Stretch,
|
|
VerticalAlignment = VerticalAlignment.Stretch
|
|
};
|
|
public Button CellButton { get; } = new()
|
|
{
|
|
Content = "",
|
|
};
|
|
Queue<Player> removedPlayers = new();
|
|
// Grid parentGrid; // Parent grid is now this itself
|
|
|
|
public BoardCell() : base()
|
|
{
|
|
CellButton.MouseEnter += CellButton_MouseEnter;
|
|
CellButton.MouseLeave += CellButton_MouseLeave;
|
|
CellButton.Click += CellButton_Click;
|
|
CellButton.Background = buttonBrush;
|
|
CellStack.Columns = 2;
|
|
CellStack.VerticalAlignment = VerticalAlignment.Top;
|
|
// Add our grid and button
|
|
_ = Children.Add(CellStack);
|
|
_ = Children.Add(CellButton);
|
|
}
|
|
|
|
private void CellButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Button cellButton = sender as Button;
|
|
System.Diagnostics.Debug.WriteLine("Button at {0}, {1} was clicked", ((Tuple<int, int>)cellButton.Tag).Item2, ((Tuple<int, int>)cellButton.Tag).Item1);
|
|
}
|
|
|
|
private void CellButton_MouseLeave(object sender, System.Windows.Input.MouseEventArgs e)
|
|
{
|
|
//throw new NotImplementedException();
|
|
}
|
|
|
|
private void CellButton_MouseEnter(object sender, System.Windows.Input.MouseEventArgs e)
|
|
{
|
|
//throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
private void Sliders_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
|
|
{
|
|
if (IsInitialized)
|
|
{
|
|
RedrawGrid();
|
|
}
|
|
}
|
|
|
|
private void GridVisibilityToggleButton_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
PreviewImageOverlay.Visibility = PreviewImageOverlay.Visibility == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible;
|
|
}
|
|
|
|
private static readonly string[] sprites = new string[]
|
|
{
|
|
"01.png",
|
|
"02.png",
|
|
"03.png",
|
|
"04.png",
|
|
};
|
|
private void DrawRandomizedPlayers_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
List<Player> randPlayers = new();
|
|
Random rand = new();
|
|
int count = rand.Next(1, 10);
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
// Create a new player at a random location
|
|
Player p = new("Player " + i, rand.Next(0, PreviewImageOverlay.RowDefinitions.Count), rand.Next(PreviewImageOverlay.ColumnDefinitions.Count));
|
|
// Load the sprite
|
|
string[] keys = new string[loadedSprites.Count];
|
|
loadedSprites.Keys.CopyTo(keys, 0);
|
|
string key = keys[rand.Next(keys.Length)];
|
|
if (key.ToLower().EndsWith(".gif"))
|
|
{
|
|
try
|
|
{
|
|
AnimatedBitmapImage animatedBitmap = new(new MemoryStream(loadedSprites[key], false), p.PlayerSprite, Application.Current.Dispatcher);
|
|
}
|
|
catch
|
|
{
|
|
BitmapSource pSprite;
|
|
{
|
|
// Scope & create the base data for pSprite
|
|
BitmapImage src = new();
|
|
src.BeginInit();
|
|
|
|
src.StreamSource = new MemoryStream(loadedSprites[key],false);
|
|
src.EndInit();
|
|
pSprite = src;
|
|
}
|
|
// Recolour:
|
|
if (rand.Next(1, 4) == 1)
|
|
{
|
|
pSprite = ImageProcessing.UpdatePixelColours(pSprite, 0.0, 0.0, 1.0);
|
|
}
|
|
p.PlayerSprite.Source = pSprite;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BitmapSource pSprite;
|
|
{
|
|
// Scope & create the base data for pSprite
|
|
BitmapImage src = new();
|
|
src.BeginInit();
|
|
src.StreamSource = new MemoryStream(loadedSprites[key], false);
|
|
src.EndInit();
|
|
pSprite = src;
|
|
}
|
|
// Recolour:
|
|
if (rand.Next(1, 4) == 1)
|
|
{
|
|
pSprite = ImageProcessing.UpdatePixelColours(pSprite, 0.0, 0.0, 1.0);
|
|
}
|
|
p.PlayerSprite.Source = pSprite;
|
|
}
|
|
|
|
randPlayers.Add(p);
|
|
}
|
|
|
|
GenerateGameBoard(randPlayers);
|
|
}
|
|
|
|
ConcurrentDictionary<string, byte[]> loadedSprites = new();
|
|
Task loadingFiles;
|
|
|
|
private void GameSpritesBrowser_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
OpenFileDialog ofd = new();
|
|
ofd.Filter = "Image Files|*.png;*.jpg;*.gif";
|
|
ofd.Multiselect = true;
|
|
if (ofd.ShowDialog() == true)
|
|
{
|
|
string[] resultFiles = ofd.FileNames;
|
|
loadedSprites.Clear();
|
|
// Run the following work in a separate thread
|
|
loadingFiles = Task.Run(() =>
|
|
{
|
|
// Continue in parallel
|
|
_ = Parallel.ForEach(resultFiles, (file) =>
|
|
{
|
|
MemoryStream ms = new();
|
|
using FileStream fs = File.OpenRead(file);
|
|
|
|
if (new FileInfo(file).Length > 512e6) // greater than 512 kB; resize the sprite to something more reasonable
|
|
{
|
|
BitmapImage gameBoardImage = new();
|
|
gameBoardImage.BeginInit();
|
|
gameBoardImage.StreamSource = fs;
|
|
gameBoardImage.CacheOption = BitmapCacheOption.Default;
|
|
gameBoardImage.EndInit();
|
|
double vRate = 128 / (double)gameBoardImage.PixelHeight; // Resize so the largest dimension is 128 px
|
|
double hRate = 128 / (double)gameBoardImage.PixelWidth;
|
|
TransformedBitmap modified = new(gameBoardImage, new ScaleTransform(gameBoardImage.PixelWidth * Math.Min(vRate, hRate), gameBoardImage.PixelHeight * Math.Min(vRate, hRate)));
|
|
PngBitmapEncoder encoder = new();
|
|
encoder.Frames.Add(BitmapFrame.Create(modified));
|
|
encoder.Save(ms);
|
|
}
|
|
else
|
|
{
|
|
fs.CopyTo(ms);
|
|
}
|
|
_ = loadedSprites.TryAdd(file, ms.ToArray());
|
|
});
|
|
// Invoke the dispatcher to add all of the sprites to the loaded sprites list
|
|
_ = Application.Current.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Render, new Action(() =>
|
|
{
|
|
LoadedSprites.Children.Clear();
|
|
foreach (KeyValuePair<string, byte[]> item in loadedSprites)
|
|
{
|
|
if (item.Key.ToLower().EndsWith(".gif"))
|
|
{
|
|
try
|
|
{
|
|
/*
|
|
// Must write-out the stream to
|
|
MediaElement gifMedia = new();
|
|
gifMedia.LoadedBehavior = MediaState.Play;
|
|
gifMedia.Source = new Uri(item.Key);
|
|
_ = LoadedSprites.Children.Add(gifMedia);
|
|
*/
|
|
Image spriteImage = new();
|
|
RBG.Helpers.AnimatedBitmapImage animatedBitmap = new(new MemoryStream(item.Value, false), spriteImage, Application.Current.Dispatcher);
|
|
_ = LoadedSprites.Children.Add(spriteImage);
|
|
}
|
|
catch
|
|
{
|
|
// On failed, use the cached data
|
|
BitmapImage image = new();
|
|
image.BeginInit();
|
|
image.StreamSource = new MemoryStream(item.Value, false);
|
|
image.EndInit();
|
|
Image spriteImage = new()
|
|
{
|
|
Source = image
|
|
};
|
|
_ = LoadedSprites.Children.Add(spriteImage);
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
BitmapImage image = new();
|
|
image.BeginInit();
|
|
image.StreamSource = new MemoryStream(item.Value, false);
|
|
image.EndInit();
|
|
Image spriteImage = new()
|
|
{
|
|
Source = image
|
|
};
|
|
_ = LoadedSprites.Children.Add(spriteImage);
|
|
}
|
|
}
|
|
}));
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|