public static PlayerData DeserializePlayerData(byte[] bytes)
{
PlayerData result_data = new PlayerData();
byte[][] data_array = ArrayConcatenation.UnmergeArrays(bytes);
//Debug.Log("Deserialized "+data_array.GetLength(0) + " arrays.");
result_data.player_name = System.Text.Encoding.UTF8.GetString(data_array[0]);
result_data.photon_view_id = BitConverter.ToInt32(data_array[1], 0);
result_data.player_id = BitConverter.ToInt32(data_array[2], 0);
result_data.is_playing = BitConverter.ToBoolean(data_array[3], 0);
result_data.is_placing = BitConverter.ToBoolean(data_array[4], 0);
result_data.left_silos = BitConverter.ToInt32(data_array[5], 0);
float[] color_data = new float[4];
byte[][] color_bytes = ArrayConcatenation.UnmergeArrays(data_array[6]);
for (int i = 0; i < color_bytes.Length; i++)
{
color_data[i] = BitConverter.ToSingle(color_bytes[i], 0);
}
result_data.player_color = new Color(color_data[0], color_data[1], color_data[2], color_data[3]);
result_data.left_missiles = BitConverter.ToInt32(data_array[7], 0);
return(result_data);
}
static byte[] SerializeMapCell(MapCellData d)
{
//Create an array of the arrays you wanna serialize together
byte[][] arrays = new byte[5][];
arrays[0] = BitConverter.GetBytes(d.has_silo);
arrays[1] = BitConverter.GetBytes(d.is_nuked);
arrays[2] = BitConverter.GetBytes(d.owner_id);
//arrays[3] = BitConverter.GetBytes(d.type);
//get bytes for neighbours
List <byte[]> neighbour_bytes = new List <byte[]>();
//if(d.adjacent_land != null)
//for (int i = 0; i < d.adjacent_land.Length; i++)
//{
//byte[][] coordinates_byte = new byte[2][];
//coordinates_byte[0] = BitConverter.GetBytes(d.adjacent_land[i].x);
//coordinates_byte[1] = BitConverter.GetBytes(d.adjacent_land[i].y);
//neighbour_bytes.Add(ArrayConcatenation.MergeArrays(coordinates_byte));
//}
//else {
byte[] no_neighbours = new byte[1];
no_neighbours[0] = (byte)0;
neighbour_bytes.Add(no_neighbours);
//}
byte[] neighbour_array = ArrayConcatenation.MergeArrays(neighbour_bytes.ToArray());
arrays[4] = neighbour_array;
//Debug.Log("Serialized "+arrays.GetLength(0) + " arrays.");
//Concatenate the arrays
byte[] bytes = ArrayConcatenation.MergeArrays(arrays);
Debug.Log(arrays.Length + " array length + bytes length" + bytes.Length);
return(bytes);
}
public byte[] SerializeEnemyData(EnemyData e_data, Enemy[] enemies_available)
{
//Create an array of the arrays you wanna serialize together
byte[][] arrays = new byte[e_data.current_enemies.Length + 2][];
arrays[0] = BitConverter.GetBytes(e_data.in_combat);
arrays[1] = BitConverter.GetBytes(e_data.current_enemies.Length);
for (int i = 0; i < e_data.current_enemies.Length; i++)
{
if (e_data.current_enemies[i] != null)
{
for (int o = 0; o < enemies_available.Length; o++)
{
if (enemies_available[o] == e_data.current_enemies[i])
{
arrays[i + 2] = BitConverter.GetBytes(o);
}
}
}
else
{
arrays[i + 2] = BitConverter.GetBytes((int)(-1));
}
}
Debug.Log("There was " + e_data.current_enemies.Length + " enemies.");
Debug.Log("Serialized " + arrays.GetLength(0) + " arrays.");
//Concatenate the arrays
return(ArrayConcatenation.MergeArrays(arrays));
}
public static byte[] SerializeGameData(GameData g_data)
{
byte[][] arrays = new byte[3][];
arrays[0] = BitConverter.GetBytes(g_data.is_match_started);
arrays[1] = BitConverter.GetBytes(g_data.players_in_room);
arrays[2] = BitConverter.GetBytes(g_data.votes_to_start);
return(ArrayConcatenation.MergeArrays(arrays));
}
//[SerializeField] public EnemyData serialize_event;
//[SerializeField] public EnemyData deserialized_event
#region MatchManager
public static byte[] SerializeMatchData(MatchData m_data)
{
byte[][] arrays = new byte[3][];
arrays[0] = BitConverter.GetBytes(m_data.is_war_on);
arrays[1] = BitConverter.GetBytes(m_data.can_match_end);
arrays[2] = BitConverter.GetBytes(m_data.is_match_over);
return(ArrayConcatenation.MergeArrays(arrays));
}
public EventData DeserializeEventData(byte[] bytes)
{
EventData result_data = new EventData();
byte[][] data_array = ArrayConcatenation.UnmergeArrays(bytes);
Debug.Log("Deserialized " + data_array.GetLength(0) + " arrays.");
result_data.current_event_id = BitConverter.ToInt32(data_array[0], 0);
result_data.is_in_event = BitConverter.ToBoolean(data_array[1], 0);
return(result_data);
}
public GameData DeserializeGameData(byte[] bytes)
{
GameData result_data = new GameData();
byte[][] data_array = ArrayConcatenation.UnmergeArrays(bytes);
Debug.Log("Deserialized " + data_array.GetLength(0) + " arrays.");
result_data.is_adventure_started = BitConverter.ToBoolean(data_array[0], 0);
result_data.players_in_room = BitConverter.ToInt32(data_array[1], 0);
return(result_data);
}
public static MatchData DeserializeMatchData(byte[] bytes)
{
MatchData result_data = new MatchData();
byte[][] data_array = ArrayConcatenation.UnmergeArrays(bytes);
result_data.is_war_on = BitConverter.ToBoolean(data_array[0], 0);
result_data.can_match_end = BitConverter.ToBoolean(data_array[1], 0);
result_data.is_match_over = BitConverter.ToBoolean(data_array[2], 0);
return(result_data);
}
public byte[] SerializeGameData(GameData g_data)
{
//Create an array of the arrays you wanna serialize together
byte[][] arrays = new byte[2][];
arrays[0] = BitConverter.GetBytes(g_data.is_adventure_started);
arrays[1] = BitConverter.GetBytes(g_data.players_in_room);
Debug.Log("Serialized " + arrays.GetLength(0) + " arrays.");
//Concatenate the arrays
return(ArrayConcatenation.MergeArrays(arrays));
}
public byte[] SerializeEventData(EventData e_data)
{
//Create an array of the arrays you wanna serialize together
byte[][] arrays = new byte[2][];
arrays[0] = BitConverter.GetBytes(e_data.current_event_id);
arrays[1] = BitConverter.GetBytes(e_data.is_in_event);
Debug.Log("Serialized " + arrays.GetLength(0) + " arrays.");
//Concatenate the arrays
return(ArrayConcatenation.MergeArrays(arrays));
}
public static byte[] SerializeMapSeed(int[] seed)
{
List <byte[]> bytes = new List <byte[]>();
for (int i = 0; i < seed.Length; i++)
{
bytes.Add(BitConverter.GetBytes(seed[i]));
}
byte[] final_cell_bytes = ArrayConcatenation.MergeArrays(bytes.ToArray());
return(final_cell_bytes);
}
public PlayerData DeserializePlayerData(byte[] bytes)
{
PlayerData result_data = new PlayerData();
byte[][] data_array = ArrayConcatenation.UnmergeArrays(bytes);
Debug.Log("Deserialized " + data_array.GetLength(0) + " arrays.");
result_data.player_name = System.Text.Encoding.UTF8.GetString(data_array[0]);
result_data.character_id = BitConverter.ToInt32(data_array[1], 0);
result_data.is_playing = BitConverter.ToBoolean(data_array[2], 0);
result_data.is_attacking = BitConverter.ToBoolean(data_array[3], 0);
return(result_data);
}
public byte[] SerializePlayerData(PlayerData p_data)
{
//Create an array of the arrays you wanna serialize together
byte[][] arrays = new byte[4][];
arrays[0] = System.Text.Encoding.UTF8.GetBytes(p_data.player_name);
arrays[1] = BitConverter.GetBytes(p_data.character_id);
arrays[2] = BitConverter.GetBytes(p_data.is_playing);
arrays[3] = BitConverter.GetBytes(p_data.is_attacking);
Debug.Log("Serialized " + arrays.GetLength(0) + " arrays.");
//Concatenate the arrays
return(ArrayConcatenation.MergeArrays(arrays));
}
public static int[] DeserializeMapSeed(byte[] map_seed_bytes)
{
Debug.Log("Deserializing Map Data!");
byte[][] bytes = ArrayConcatenation.UnmergeArrays(map_seed_bytes);
List <int> seed = new List <int>();
for (int i = 0; i < bytes.Length; i++)
{
seed.Add(BitConverter.ToInt32(bytes[i], 0));
}
Debug.Log("Finished deserializing map!");
return(seed.ToArray());
}
static MapCellData DeserializeMapCell(byte[] bytes)
{
byte[][] data_array = ArrayConcatenation.UnmergeArrays(bytes);
MapCellData cell = new MapCellData();
cell.has_silo = BitConverter.ToBoolean(data_array[0], 0);
cell.is_nuked = BitConverter.ToBoolean(data_array[1], 0);
cell.owner_id = BitConverter.ToInt32(data_array[2], 0);
Debug.Log(data_array.Length);
Debug.Log(data_array[4].Length);
byte[][] land_bytes = ArrayConcatenation.UnmergeArrays(data_array[4]);
List <Vector2> deserialized_coords = new List <Vector2>();
return(cell);
}
public EnemyData DeserializeEnemyData(byte[] bytes, Enemy[] enemies_available)
{
EnemyData result_data = new EnemyData();
byte[][] data_array = ArrayConcatenation.UnmergeArrays(bytes);
Debug.Log("Deserialized " + data_array.GetLength(0) + " arrays.");
result_data.in_combat = BitConverter.ToBoolean(data_array[0], 0);
int enemy_quantity = BitConverter.ToInt32(data_array[1], 0);
Debug.Log("There are " + enemy_quantity + " enemies");
Enemy[] new_enemy_list = new Enemy[enemy_quantity];
for (int i = 2; i < enemy_quantity + 2; i++)
{
int character_id = BitConverter.ToInt32(data_array[i], 0);
//if(character_id != -1)
//new_enemy_list.Add(enemies_available[character_id]);
}
result_data.current_enemies = new_enemy_list;
return(result_data);
}
public static byte[] SerializePlayerData(PlayerData p_data)
{
//Create an array of the arrays you wanna serialize together
byte[][] arrays = new byte[8][];
arrays[0] = System.Text.Encoding.UTF8.GetBytes(p_data.player_name);
arrays[1] = BitConverter.GetBytes(p_data.photon_view_id);
arrays[2] = BitConverter.GetBytes(p_data.player_id);
arrays[3] = BitConverter.GetBytes(p_data.is_playing);
arrays[4] = BitConverter.GetBytes(p_data.is_placing);
arrays[5] = BitConverter.GetBytes(p_data.left_silos);
byte[][] color_bytes = new byte[4][];
color_bytes[0] = BitConverter.GetBytes(p_data.player_color.r);
color_bytes[1] = BitConverter.GetBytes(p_data.player_color.g);
color_bytes[2] = BitConverter.GetBytes(p_data.player_color.b);
color_bytes[3] = BitConverter.GetBytes(p_data.player_color.a);
arrays[6] = ArrayConcatenation.MergeArrays(color_bytes);
arrays[7] = BitConverter.GetBytes(p_data.left_missiles);
return(ArrayConcatenation.MergeArrays(arrays));
}
