private void Serialise()
{
byte[] typeBytes = BitConverter.GetBytes((int)Type);
byte[] targetIDBytes = BitConverter.GetBytes(TargetID);
byte terminateBytes = Convert.ToByte(Terminate);
for (int i = 0; i < typeBytes.Length; i++)
{
Bytes[i] = typeBytes[i];
}
for (int i = 0; i < targetIDBytes.Length; i++)
{
Bytes[i + 4] = targetIDBytes[i];
}
Bytes[8] = terminateBytes;
for (int i = 0; i < Data.Length; i++)
{
Bytes[i + 9] = Data[i];
}
Polymono.Debug($"Packet serialised: {Environment.NewLine} " +
$"[Type: {Type}->{PrintByteArray(typeBytes)}] {Environment.NewLine} " +
$"[Target ID: {TargetID}->{PrintByteArray(targetIDBytes)}] {Environment.NewLine} " +
$"[Terminate: {Terminate}->{terminateBytes}] {Environment.NewLine} " +
$"[Data: {PrintByteArray(Data)}]");
}
public void Click(Vector2 vector)
{
vector.Y = WindowHeight - vector.Y;
Vector3 position = Models[Selector].Position;
bool isHovering = PointInRectangle(
new Vector2(position.X, position.Y),
new Vector2(position.X + Width, position.Y),
new Vector2(position.X + Width, position.Y - Height),
new Vector2(position.X, position.Y - Height), vector);
if (isHovering && !Models[Selector].IsHidden)
{
Polymono.Debug($"Checkbox clicked: [{ID}]");
if (State == ControlState.Normal)
{
State = ControlState.Clicked;
Selector = "Clicked";
}
else
{
State = ControlState.Normal;
Selector = "Default";
}
}
}
public async void Click(Vector2 vector)
{
vector.Y = WindowHeight - vector.Y;
Vector3 position = Models[Selector].Position;
bool isHovering = PointInRectangle(
new Vector2(position.X, position.Y),
new Vector2(position.X + Width, position.Y),
new Vector2(position.X + Width, position.Y - Height),
new Vector2(position.X, position.Y - Height), vector);
if (isHovering && !Models[Selector].IsHidden && State != ControlState.Clicked)
{
Polymono.Debug($"Button clicked: {Text}[{ID}]");
State = ControlState.Clicked;
Selector = "Clicked";
try
{
await ExecDelegate();
}
catch (Exception e)
{
Polymono.Error(e.Message);
Polymono.ErrorF(e.StackTrace);
}
State = ControlState.Normal;
Selector = "Default";
}
}
public static Packet[] Create(PacketType type, int targetID, string data)
{
Polymono.Debug($"Data length: {data.Length}");
int PacketsToCreate = (data.Length / DataSize) + 1;
Polymono.Debug($"Number of packets: {PacketsToCreate}");
Packet[] packets = new Packet[PacketsToCreate];
for (int i = 0; i < PacketsToCreate; i++)
{
Polymono.Debug($"Interation: {i}");
int size;
bool terminate;
if (data.Length - (i * DataSize) < DataSize)
{
// Last Packet to populate.
size = data.Length - (i * DataSize);
terminate = true;
}
else
{
// There are more packets to populate.
size = DataSize;
terminate = false;
}
packets[i] = new Packet(type, targetID, terminate, data.Substring(i * DataSize, size));
packets[i].Encode();
}
return(packets);
}
public Client(GameClient gameClient, bool v6 = true)
{
GameClient = gameClient;
V6 = v6;
NetworkHandler = new SocketHandler(v6);
Packets = new Queue <Packet>();
Polymono.Debug("Client initialised.");
}
public void AddPlayer(int id, string name)
{
Polymono.Debug($"Board::AddPlayer(ID: {id}, Name: {name})");
Player player = new Player(PlayerProgram, this)
{
PlayerName = name
};
Players[id] = player;
SetPlayerPosition(id, 0);
}
public Server(GameClient gameClient, string name, bool v6 = true)
{
GameClient = gameClient;
V6 = v6;
//Clients = new ISocket[Polymono.MaxPlayers];
//Clients[ID] = new SocketHandler(v6);
GameClient.Board.AddPlayer(ID, name);
GetClients()[ID].SetNetworkHandle(new SocketHandler(v6));
Packets = new Queue <Packet>();
Polymono.Debug("Server initialised. [IPv6: " + v6 + "]");
}
private void Deserialise()
{
Type = (PacketType)BitConverter.ToInt32(Bytes, PacketHandler.TypeOffset);
TargetID = BitConverter.ToInt32(Bytes, PacketHandler.TargetIDOffset);
Terminate = BitConverter.ToBoolean(Bytes, PacketHandler.TerminateOffset);
Buffer.BlockCopy(Bytes, PacketHandler.DataOffset, Data, 0, PacketHandler.DataSize);
Polymono.Debug($"Packet deserialised: {Environment.NewLine} " +
$"[Type: {Type}] {Environment.NewLine} " +
$"[Target ID: {TargetID}] {Environment.NewLine} " +
$"[Terminate: {Terminate}] {Environment.NewLine} " +
$"[Data Bytes: {PrintByteArray(Data)}]");
}
public int CreateTexture(string path, int quality = 1, bool repeat = false, bool flip_y = false)
{
Bitmap bitmap;
try
{
bitmap = new Bitmap(path);
}
catch (FileNotFoundException e)
{
Polymono.Debug($"Cannot find {path}: {e}");
return(-1);
}
if (flip_y)
{
bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
}
int texture = GL.GenTexture();
GL.BindTexture(TextureTarget.Texture2D, texture);
switch (quality)
{
case 0:
default:
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear);
break;
case 1:
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Nearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Nearest);
break;
}
if (repeat)
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)All.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)All.Repeat);
}
else
{
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)All.ClampToEdge);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)All.ClampToEdge);
}
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bitmap.Width, bitmap.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero);
System.Drawing.Imaging.BitmapData bitmap_data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height),
System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, bitmap.Width, bitmap.Height, PixelFormat.Bgra, PixelType.UnsignedByte, bitmap_data.Scan0);
bitmap.UnlockBits(bitmap_data);
bitmap.Dispose();
GL.BindTexture(TextureTarget.Texture2D, 0);
return(texture);
}
public void MoveSpaces(int spaces, int playerID)
{
Polymono.Debug($"Board::MoveSpaces(spaces: {spaces}, sender: {playerID})");
// TODO: Gradual player movement.
Players[playerID].NextLocation = NextPropertyID(Players[playerID].CurrentLocation);
int step = Players[playerID].CurrentLocation;
for (int i = 1; i < spaces + 1; i++)
{
step = NextPropertyID(step);
}
Players[playerID].FinalLocation = step;
}
public bool UpdatePositions(int playerID, float updateFrequency)
{
updateFrequency /= MovementSpeed;
Player player = Players[playerID];
if (player.CurrentLocation == player.FinalLocation)
{
return(false);
}
// Points of the line.
Vector3 BeginPoint = player.OriginPosition;
Vector3 EndPoint = Properties[player.NextLocation].BoardLocationOffset + GetOffsetByPlayers(player.NextLocation);
// The difference vector.
Vector3 Difference = EndPoint - BeginPoint;
Vector3 UpdateDiff = Difference / updateFrequency;
// Updated player position.
Vector3 pastPosition = player.Position;
Vector3 NewPosition = player.Position + UpdateDiff;
player.Position = NewPosition;
// Magnitudes
float completeMagnitude = Difference.Length;
float firstPartialMagnitude = (NewPosition - BeginPoint).Length;
float secondPartialMagnitude = UpdateDiff.Length;
float adjustedMagnitude = firstPartialMagnitude + secondPartialMagnitude;
// Check magnitudes
if (completeMagnitude <= adjustedMagnitude)
{
Polymono.Debug($"Board::UpdatePosition(ID, UpFreq): End of movement segment.");
// If magnitude is further than is supposed to be, or equal, force position -> Finish.
player.Position = EndPoint;
player.OriginPosition = EndPoint;
player.CurrentLocation = player.NextLocation;
if (player.CurrentLocation != player.FinalLocation)
{
player.NextLocation = NextPropertyID(player.CurrentLocation);
return(false);
}
else if (player.CurrentLocation == player.FinalLocation)
{
Polymono.Debug($"Board::UpdatePosition(ID, UpFreq): Movement finished.");
GameClient.State = GameState.PlayerOptions;
// Moving is done, fully.
return(true);
}
}
return(false);
}
public void EndCurrentTurn(int playerID)
{
Polymono.Debug($"Board::EndCurrentTurn(ID: {playerID})");
// If in lobby roll phase.
if (GameClient.State == GameState.LobbyRoll)
{
int nextPlayerTurn = CurrentPlayerTurn + 1;
// If end of lobby roll phase
if (nextPlayerTurn >= GetPlayers().Count)
{
// Carry on
// Assign an order list and start over.
CompleteOrder();
CurrentPlayerTurn = PlayerOrder[0];
GameClient.State = GameState.PlayerOptions;
}
else
{
CurrentPlayerTurn += 1;
}
}
else if (GameClient.State == GameState.PlayerOptions)
{
// End turn pressed.
for (int i = 0; i < PlayerOrder.Length; i++)
{
// Get current turn's position.
if (PlayerOrder[i] == CurrentPlayerTurn)
{
// Current playerOrder, increment order.
if (i + 1 >= PlayerOrder.Length)
{
CurrentPlayerTurn = PlayerOrder[0];
}
else
{
CurrentPlayerTurn = PlayerOrder[i + 1];
}
break;
}
}
}
}
public static Packet[] Create(PacketType type, int targetID, byte[] data)
{
Polymono.Debug($"====== PacketHandler creation ======");
Polymono.Debug($"Data length: {data.Length}");
int PacketsToCreate = (data.Length / DataSize) + 1;
Polymono.Debug($"Number of packets: {PacketsToCreate}");
Packet[] packets = new Packet[PacketsToCreate];
for (int i = 0; i < PacketsToCreate; i++)
{
int iterationOffset = (i * DataSize);
int iterationSize = data.Length - iterationOffset;
Polymono.Debug($"Interation: {i}");
Polymono.Debug($"Interation offset: {iterationOffset}");
Polymono.Debug($"Interation size: {iterationSize}");
if (iterationSize < DataSize)
{
// Last Packet to populate.
byte[] temp = new byte[iterationSize];
for (int n = 0; n < iterationSize; n++)
{
temp[n] = data[n + iterationOffset];
}
packets[i] = new Packet(type, targetID, true, temp);
}
else
{
// There are more packets to populate.
// Create temporary set of bytes.
byte[] temp = new byte[DataSize];
for (int n = 0; n < DataSize; n++)
{
temp[n] = data[n + iterationOffset];
}
packets[i] = new Packet(type, targetID, false, temp);
}
}
Polymono.Debug($"====== PacketHandler finished ======");
return(packets);
}
public async void Click(Vector2 vector)
{
vector.Y = WindowHeight - vector.Y;
Vector3 position = Models[Selector].Position;
bool isHovering = PointInRectangle(
new Vector2(position.X, position.Y),
new Vector2(position.X + Width, position.Y),
new Vector2(position.X + Width, position.Y - Height),
new Vector2(position.X, position.Y - Height), vector);
if (isHovering && !Models[Selector].IsHidden)
{
if (State == ControlState.Unfocused || State == ControlState.Normal)
{
Polymono.Debug($"Textbox clicked: {Text}[{ID}]");
// Unfocus everything else.
foreach (var control in Controls.Values)
{
if (control is Textbox textbox)
{
if (textbox.State == ControlState.Focused)
{
textbox.State = ControlState.Unfocused;
textbox.Selector = "Default";
}
}
}
// Focus this object.
State = ControlState.Focused;
Selector = "Focused";
}
else
{
State = ControlState.Unfocused;
Selector = "Default";
}
}
}
public void FinalisePlayerMovement(int playerID)
{
Polymono.Debug($"Board::FinalisePlayerMovement(ID: {playerID})");
SetPlayerPosition(playerID, Players[playerID].FinalLocation);
}
